Java PofExtractor类代码示例

import com.tangosol.util.extractor.PofExtractor; //导入依赖的package包/类
private <T> ValueExtractor provideExtractorForValue(Class<T> clazz, int target, List<String> chainOfProperties) {
    Class<?> propertyClass = clazz;
    List<Integer> indices = Lists.newArrayList();

    for (String property : chainOfProperties) {
        Field field;
        try {
            field = clazz.getDeclaredField(property);
        } catch (NoSuchFieldException e) {
            throw new InvalidQueryException(e);
        }

        PortableProperty portablePropertyAnnotation = field.getAnnotation(PortableProperty.class);
        if (portablePropertyAnnotation == null) {
            throw new InvalidQueryException("");
        }

        // TODO add support for customs codecs some day ;)
        int index = portablePropertyAnnotation.value();
        indices.add(index);
        propertyClass = field.getDeclaringClass();
    }

    return new PofExtractor<>(propertyClass, new SimplePofPath(Ints.toArray(indices)), target);
}
 

import com.tangosol.util.extractor.PofExtractor; //导入依赖的package包/类
private String buildElement(BackingMapContext bmc, String path, long docId, int docType) {

    	Set<Integer> parts = mDictionary.getPathElements(docType, path);
   		Filter f = new AndFilter(
   			new EqualsFilter(new PofExtractor(Long.TYPE, 2), docId),
			new InFilter(new PofExtractor(Integer.TYPE, 4), parts));
   		
        Set<Map.Entry> xdEntries = QueryHelper.INSTANCE.query(bmc, f, true, false, null);
       	return null; //buildXml(xdEntries);
    }
 

import com.tangosol.util.extractor.PofExtractor; //导入依赖的package包/类
@Override
public void deleteDocument(Entry<Long, XDMDocument> entry) {
	logger.trace("deleteDocument.enter; entry: {}", entry);
	BinaryEntry docEntry = (BinaryEntry) entry;
	if (!docEntry.isPresent()) {
		throw new IllegalStateException("Document Entry with id " + entry.getKey() + " not found");
	}

	Long id = entry.getKey();
	BackingMapManagerContext ctx = docEntry.getContext();
	BackingMapContext xdmCtx = ctx.getBackingMapContext(CN_XDM_ELEMENT);

  		Filter f = new EqualsFilter(new PofExtractor(Long.class, 2), id);
       Set<Map.Entry> xdEntries = QueryHelper.INSTANCE.query(xdmCtx, f, true, false, null);
	logger.trace("deleteDocument; removing {} entries for docId: {}", xdEntries.size(), id);
       for (Map.Entry xdEntry : xdEntries) {
       	//((BinaryEntry) xdEntry).remove(false);
       	Object xdKey = ((BinaryEntry) xdEntry).getBinaryKey();
   		//logger.trace("process; removing entry for key: {}", xdKey);
       	xdmCtx.getBackingMap().remove(xdKey);
       	//xdEntry.setValue(null);
   		//logger.trace("process; removing {} entries for docId: {}", xdEntry.size(), id);
       }

       docEntry.remove(false);
	logger.trace("deleteDocument.exit; removed: {}", true);
}
 

import com.tangosol.util.extractor.PofExtractor; //导入依赖的package包/类
@Override
public Long getDocumentId(String uri) {
	Filter f = new EqualsFilter(new PofExtractor(String.class, 1), uri);
	Set<Long> docKeys = new HashSet<Long>(xddCache.keySet(f));
	if (docKeys.size() == 0) {
		return null;
	}
	// todo: check if too many docs ??
	return docKeys.iterator().next();
}
 

import com.tangosol.util.extractor.PofExtractor; //导入依赖的package包/类
protected Set<Long> queryPathKeys(Set<Long> found, PathExpression pex, Object value) {

		int pathId = -1;
		if (pex.isRegex()) {
			Set<Integer> pathIds = mDictionary.translatePathFromRegex(pex.getDocType(), pex.getRegex());
			logger.trace("queryPathKeys; regex: {}; pathIds: {}", pex.getRegex(), pathIds);
			if (pathIds.size() > 0) {
				pathId = pathIds.iterator().next();
			}
		} else {
			String path = pex.getFullPath();
			logger.trace("queryPathKeys; path: {}; comparison: {}", path, pex.getCompType());
			pathId = mDictionary.translatePath(pex.getDocType(), path, XDMNodeKind.fromPath(path)).getPathId();
		}
		//String val = value.toString();
		Filter valueFilter = getValueFilter(pex, value);
		if (valueFilter == null) {
			throw new IllegalArgumentException("Can't construct filter for expression: " + pex);
		}

		Filter f = new AndFilter(
				new EqualsFilter(new PofExtractor(Integer.class, 4), pathId), valueFilter);
		Set<XDMDataKey> keys = xdmCache.keySet(f);
		logger.trace("queryPathKeys; path: {}, value: {}; got keys: {}; cache size: {}", 
				pathId, value, keys.size(), xdmCache.size()); 
		
		if (keys.size() > 0) {
			Set<Long> docIds = new HashSet<Long>();
			for (XDMDataKey key: keys) {
				docIds.add(key.getDocumentId());
			}
			found.retainAll(docIds);
		} else {
			found.clear();
		}
		return found;
	}
 

import com.tangosol.util.extractor.PofExtractor; //导入依赖的package包/类
public static Object extractFromObject(ValueExtractor extractor, Object object, Serializer serialiser) {
    if (extractor instanceof PofExtractor) {
        PofNavigator navigator = ((PofExtractor) extractor).getNavigator();
        PofValue pofValue = PofValueParser.parse((Binary) object, (PofContext) serialiser);
        return navigator.navigate(pofValue).getValue();
    }

    if (object instanceof Binary) {
        Object deserialised = ExternalizableHelper.fromBinary((Binary)object, serialiser);
        return extractor.extract(deserialised);
    }

    return extractor.extract(object);
}
 

import com.tangosol.util.extractor.PofExtractor; //导入依赖的package包/类
@Test
public void shouldThrowIfNoIndexMatchingExtractor() {
    // Given:
    NamedCache cache = givenSomeDataInCache("pof-distributed-cache-test", 7);
    PofExtractor unknownExtractor = new PofExtractor(null, 101);

    try {
        // When:
        cache.aggregate(AlwaysFilter.INSTANCE, new IndexContentExtractor(unknownExtractor));
    } catch (PortableException e){
        assertThat(e.getCause(), instanceOf(PortableException.class));
        assertThat(((PortableException)e.getCause()).getName(), containsString(IllegalStateException.class.getCanonicalName()));
    }
}