Java Node.getOperator方法代码示例

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

    if (operator.equals("text")) {
        if (index.containsPart("stemmedPostings")) {
            return stemmedNode(original);
        } else if (index.containsPart("postings")) {
            return transformedNode(original, "extents", "postings");
        } else {
            return original;
        }
    } else if (operator.equals("field") || operator.equals("any")) {
        if (index.containsPart("extents")) {
            return transformedNode(original, "extents", "extents");
        } else {
            return original;
        }
    } else {
        return original;
    }
}
 

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 String getClassName(Node node) throws Exception {
    String operator = node.getOperator();

    if (operator.equals("feature")) {
        return getFeatureClassName(node.getParameters());
    }
    OperatorSpec operatorType = operatorLookup.get(operator);

    if (operatorType == null) {
        throw new IllegalArgumentException(
                "Unknown operator name: #" + operator);
    }
    return operatorType.className;
}
 

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 IndexIterator getIterator(Node node) throws IOException {
    if (node.getOperator().equals("scores")) {
        return getScores(node.getDefaultParameter());
    } else {
        throw new UnsupportedOperationException(
            "Index doesn't support operator: " + node.getOperator());
    }
}
 

import org.galagosearch.core.retrieval.query.Node; //导入方法依赖的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.Node; //导入方法依赖的package包/类
public IndexIterator getIterator(Node node) throws IOException {
    if (node.getOperator().equals("extents")) {
        return getExtents(node.getDefaultParameter());
    } else {
        throw new UnsupportedOperationException("Node type " + node.getOperator() +
                                                " isn't supported.");
    }
}