Java NodeType类代码示例

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
/**
 * Given a query node, generates the corresponding iterator object that can be used
 * for structured retrieval.  This method just calls getClass() on the node,
 * then instantiates the resulting class.
 * 
 * If the class returned by getClass() is a ScoringFunction, it must contain
 * a constructor that takes a single Parameters object.  If the class returned by 
 * getFeatureClass() is some kind of StructuredIterator (either a ScoreIterator,
 * ExtentIterator or CountIterator), it must take a Parameters object and an
 * ArrayList of DocumentDataIterators as parameters.
 */
public StructuredIterator getIterator(Node node, ArrayList<StructuredIterator> childIterators) throws Exception {
    NodeType type = getNodeType(node);
    
    Constructor constructor = type.getConstructor();
    Class[] types = type.getParameterTypes(1 + childIterators.size());
        
    if (!isUsableConstructor(types, childIterators)) {
        throw new Exception("Couldn't find a reasonable constructor.");
    }
    
    Parameters parametersCopy = new Parameters();
    parametersCopy.copy(node.getParameters());
    Object[] args = argsForConstructor(constructor.getParameterTypes(),
                                       parametersCopy,
                                       childIterators);
    RequiredStatistics required =
        type.getIteratorClass().getAnnotation(RequiredStatistics.class);
    if (required != null) {
        for (String statistic : required.statistics()) {
            parametersCopy.add(statistic, parameters.get(statistic, null));
        }
    }
    return (StructuredIterator) constructor.newInstance(args);
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public Node afterNode(Node node) throws Exception {
    ArrayList<Node> newChildren = new ArrayList<Node>();
    NodeType nodeType = retrieval.getNodeType(node);
    if (nodeType == null) return node;
    ArrayList<Node> children = node.getInternalNodes();
    // Given that we're going to pass children.size() + 1 parameters to
    // this constructor, what types should those parameters have?
    Class[] types = nodeType.getParameterTypes(children.size() + 1);
    if (types == null) return node;

    for (int i = 1; i < types.length; ++i) {
        Node child = children.get(i-1);
        // If the parent will expect a ScoreIterator at this position, but
        // we've got a CountIterator here, we'll perform a conversion step.
        if (ScoreIterator.class.isAssignableFrom(types[i]) &&
            isCountNode(children.get(i-1))) {
            Node feature = createSmoothingNode(child);
            newChildren.add(feature);
        } else {
            newChildren.add(child);
        }
    }

    return new Node(node.getOperator(), node.getParameters(),
                    newChildren, node.getPosition());
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public NodeType getNodeType(Node node) throws Exception {
    NodeType nodeType = index.getNodeType(node);
    if (nodeType == null) {
        nodeType = featureFactory.getNodeType(node);
    }
    return nodeType;
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public NodeType getNodeType(Node node) throws IOException {
    NodeType result = null;
    StructuredIndexPartReader part = getIndexPart(node);
    if (part != null) {
        final String operator = node.getOperator();
        final Map<String, NodeType> nodeTypes = part.getNodeTypes();
        result = nodeTypes.get(operator);
    }
    return result;
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public void testIsStructuredIteratorOrArray() {
    NodeType n = new NodeType(ExtentIterator.class);
    assertTrue(n.isStructuredIteratorOrArray(ExtentIterator.class));
    assertTrue(n.isStructuredIteratorOrArray(StructuredIterator.class));
    assertFalse(n.isStructuredIteratorOrArray(Integer.class));
    assertFalse(n.isStructuredIteratorOrArray(Date.class));
    assertTrue(n.isStructuredIteratorOrArray(new ExtentIterator[0].getClass()));
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public void testGetInputs() throws Exception {
    NodeType n = new NodeType(FakeIterator.class);
    Class[] input = n.getInputs();
    assertEquals(3, input.length);
    assertEquals(Parameters.class, input[0]);
    assertEquals(ExtentIterator.class, input[1]);
    assertEquals(new StructuredIterator[0].getClass(), input[2]);
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public void testGetParameterTypes() throws Exception {
    NodeType n = new NodeType(FakeIterator.class);
    Class[] input = n.getParameterTypes(5);
    assertEquals(5, input.length);
    assertEquals(Parameters.class, input[0]);
    assertEquals(ExtentIterator.class, input[1]);
    assertEquals(StructuredIterator.class, input[2]);
    assertEquals(StructuredIterator.class, input[3]);
    assertEquals(StructuredIterator.class, input[4]);
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public void testGetConstructor() throws Exception {
    NodeType n = new NodeType(FakeIterator.class);
    Constructor c = n.getConstructor();
    Constructor actual =
            FakeIterator.class.getConstructor(Parameters.class, ExtentIterator.class,
                                              new StructuredIterator[0].getClass());
    assertEquals(actual, c);
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
/**
 * Test of getNodeType method, of class FeatureFactory.
 */
public void testGetNodeType() throws Exception {
    FeatureFactory f = new FeatureFactory(new Parameters());
    NodeType type = f.getNodeType(new Node("combine", ""));
    Class c = type.getIteratorClass();
    assertEquals(UnfilteredCombinationIterator.class.getName(), c.getName());
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public NodeType getNodeType(Node node) throws Exception {
    return new NodeType(getClass(node));
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public boolean isCountNode(Node node) throws Exception {
    NodeType nodeType = retrieval.getNodeType(node);
    if (nodeType == null) return false;
    Class outputClass = nodeType.getIteratorClass();
    return CountIterator.class.isAssignableFrom(outputClass);
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public Map<String, NodeType> getNodeTypes() {
    HashMap<String, NodeType> nodeTypes = new HashMap<String, NodeType>();
    nodeTypes.put("scores", new NodeType(Iterator.class));
    return nodeTypes;
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public Map<String, NodeType> getNodeTypes() {
    HashMap<String, NodeType> types = new HashMap<String, NodeType>();
    types.put("counts", new NodeType(Iterator.class));
    types.put("extents", new NodeType(Iterator.class));
    return types;
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public HashMap<String, NodeType> getNodeTypes() {
    HashMap<String, NodeType> nodeTypes = new HashMap<String, NodeType>();
    nodeTypes.put("extents", new NodeType(Iterator.class));
    return nodeTypes;
}
 

import org.galagosearch.core.retrieval.query.NodeType; //导入依赖的package包/类
public void testGetIteratorClass() {
    NodeType n = new NodeType(ExtentIterator.class);
    assertEquals(ExtentIterator.class, n.getIteratorClass());
}