Java Node.getInternalNodes方法代码示例

import org.galagosearch.core.retrieval.query.Node; //导入方法依赖的package包/类
public Node afterNode(Node node) throws Exception {
    ArrayList<Node> children = node.getInternalNodes();
    if (node.getOperator().equals("weight")) {
        // first, verify that the appropriate children are weights
        if (children.size() % 2 == 1) {
            throw new IOException("A weighted node cannot have an odd number of internal nodes: " +
                    node.getInternalNodes().size());
        }
                    
        // now, reassemble everything:
        ArrayList<Node> newChildren = new ArrayList<Node>();
        for (int i = 0; i < children.size(); i += 2) {
            Node weightNode = children.get(i);
            Node childNode = children.get(i+1);
            
            ArrayList<Node> newChild = new ArrayList<Node>();
            newChild.add(childNode);
            Node scaledNode = new Node("scale", getWeight(weightNode), newChild);
            newChildren.add(scaledNode);
        }

        return new Node("combine", newChildren);
    } else {
        return node;
    }
}
 

import org.galagosearch.core.retrieval.query.Node; //导入方法依赖的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.Node; //导入方法依赖的package包/类
public Node afterNode(Node node) throws Exception {
    ArrayList<Node> children = new ArrayList<Node>();

    if (node.getOperator().equals("combine")) {
        ArrayList<Node> oldChildren = node.getInternalNodes();
        for (int i = 0; i < oldChildren.size(); i++) {
            Node child = oldChildren.get(i);
            boolean isStopword = child.getOperator().equals("text") &&
                                 words.contains(child.getDefaultParameter());
            if (!isStopword) {
                children.add(child);
            }
        }

        return new Node(node.getOperator(), children);
    }
    
    return node;
}
 

import org.galagosearch.core.retrieval.query.Node; //导入方法依赖的package包/类
public StructuredIterator createIterator(Node node) throws Exception {
    ArrayList<StructuredIterator> internalIterators = new ArrayList<StructuredIterator>();

    for (Node internalNode : node.getInternalNodes()) {
        StructuredIterator internalIterator = createIterator(internalNode);
        internalIterators.add(internalIterator);
    }
    
    StructuredIterator iterator = index.getIterator(node);
    if (iterator == null) {
        iterator = featureFactory.getIterator(node, internalIterators);
    }
    
    return iterator;
}
 

import org.galagosearch.core.retrieval.query.Node; //导入方法依赖的package包/类
private Node stemmedNode(Node original) {
    Parameters parameters = original.getParameters().clone();
    parameters.add("part", "stemmedPostings");
    String term = parameters.get("default");
    stemmer.setCurrent(term);
    stemmer.stem();
    String stemmed = stemmer.getCurrent();
    parameters.set("default", stemmed);
    return new Node("extents", parameters, original.getInternalNodes(), original.getPosition());
}
 

import org.galagosearch.core.retrieval.query.Node; //导入方法依赖的package包/类
public Node afterNode(Node original) {
    String operator = original.getOperator();
    ArrayList<Node> children = original.getInternalNodes();

    if (operator.length() == 0) {
        return original;
    }

    if (Character.isDigit(operator.codePointAt(0))) {
        // this is a #n node, which is an ordered window node
        return new Node("od", operator, children, original.getPosition());
    } else if (operator.startsWith("od") &&
            operator.length() > 2 &&
            Character.isDigit(operator.codePointAt(2))) {
        // this is a #od3() node
        return new Node("od", operator.substring(2),
                children, original.getPosition());
    } else if (operator.startsWith("uw") &&
            operator.length() > 2 &&
            Character.isDigit(operator.codePointAt(2))) {
        // this is a #uw3 node
        return new Node("uw", operator.substring(2),
                children, original.getPosition());
    }

    return original;
}
 

import org.galagosearch.core.retrieval.query.Node; //导入方法依赖的package包/类
public Node transformedNode(Node original,
        String operatorName, String indexName) {
    Parameters parameters = original.getParameters().clone();
    parameters.add("part", indexName);
    return new Node(operatorName, parameters, original.getInternalNodes(), original.getPosition());
}