Java Path.isIndex方法代码示例

import com.redhat.lightblue.util.Path; //导入方法依赖的package包/类
@Override
public IdentityExtractor getArrayIdentityExtractor(Path arrayField) {
    MutablePath p = new MutablePath();
    int n = arrayField.numSegments();
    for (int i = 0; i < n; i++) {
        if (arrayField.isIndex(i)) {
            p.push(Path.ANY);
        } else {
            p.push(arrayField.head(i));
        }
    }
    if(ignoredIdentities.contains(p))
        return null;
    else {
        ArrayIdentityFields fields = getArrayIdentities().get(p);
        if (fields != null) {
            return getArrayIdentityExtractorImpl(fields);
        }
    }
    return null;
}
 

import com.redhat.lightblue.util.Path; //导入方法依赖的package包/类
/**
 * Input is a path to an array element
 * Output is the array containing that element, and all indexes replaced with *
 */
private Path getArray(Path p) {
    int lastIndex=p.numSegments()-1;
    while(lastIndex>0) {
        if(p.isIndex(lastIndex))
            break;
        lastIndex--;
    }
    MutablePath mp=new MutablePath();
    for(int i=0;i<lastIndex;i++) {
        if(p.isIndex(i))
            mp.push(Path.ANY);
        else
            mp.push(p.head(i));
    }
    return mp.immutableCopy();
}
 

import com.redhat.lightblue.util.Path; //导入方法依赖的package包/类
private void addField(DBObject doc,
                      List<DocComparator.Delta<Object>> delta,
                      DocComparator.Removal<Object> removedField) {
    Path field = removedField.getField1();
    // 'field' is the name of the removed field in the old document.
    // We have to find the field name it has in the new document, because array elements might have moved around

    MutablePath newFieldName = new MutablePath();
    int n = field.numSegments();
    for (int i = 0; i < n; i++) {
        if (field.isIndex(i)) {               
            // At this point, newFieldName points to an array,
            // field.prefix(i) points to an array element. If there
            // is a Move delta for the move of field.prefix(i+1)
            // -> someField, then we get the new index from
            // someField
            Path arrayElement = field.prefix(i+1);
            // arrayElement.tail(0) is an index
            Path movedTo = null;
            for (DocComparator.Delta<Object> d : delta) {
                if (d instanceof DocComparator.Move) {
                    DocComparator.Move<Object> move = (DocComparator.Move<Object>) d;
                    if (move.getField1().equals(arrayElement)) {
                        movedTo = move.getField2();
                        break;
                    }
                }
            }
            LOGGER.debug("field: {}, arrayElement: {}, movedTo:{}", field,arrayElement,movedTo);
            if (movedTo != null) {
                // arrayElement moved to somewhere else, get the new index, push it to the newFieldName
                newFieldName.push(movedTo.tail(0));
            } else {
                // ArrayElement did not move
                newFieldName.push(field.head(i));
            }
        } else {
            newFieldName.push(field.head(i));
        }
    }
    // At this point, newFieldName contains the field in the new document
    LOGGER.debug("Adding contents of {} to {}", field, newFieldName);
    DBObject parent;
    if (newFieldName.numSegments() > 1) {
        parent = (DBObject) DocTranslator.getDBObject(doc, newFieldName.prefix(-1));
    } else {
        parent = doc;
    }
    parent.put(newFieldName.tail(0), copy(removedField.getRemovedNode()));
}
 

import com.redhat.lightblue.util.Path; //导入方法依赖的package包/类
private FieldInfo resolveFieldForQuery(FieldTreeNode context,Path contextPath,Path field) {
    int n=field.numSegments();
    // Two paths: p: the full thing, s: only the relative field
    // If the field reference moves to a parent of relative field, we use p
    // otherwise, we use s
    MutablePath p=new MutablePath(contextPath);
    MutablePath s=new MutablePath();
    FieldTreeNode fieldNode=context;
    for(int i=0;i<n;i++) {
        String seg=field.head(i);
        if(field.isIndex(i)) {
            p.push(seg);
            if(s!=null)
                s.push(seg);
            if(fieldNode instanceof ArrayField) {
                fieldNode=((ArrayField)fieldNode).getElement();
            } else {
                throw Error.get(ERR_INVALID_FIELD,field.toString());
            }
        } else {
            if(Path.THIS.equals(seg)) {
                // Don't push anything
                ;
            } else if(Path.PARENT.equals(seg)) {
                p.pop();
                if(s!=null)
                    if(s.isEmpty())
                        s=null;
                    else
                        s.pop();
                fieldNode=fieldNode.getParent();
            } else {
                p.push(seg);
                if(s!=null)
                    s.push(seg);
                fieldNode=fieldNode.resolve(new Path(seg));
            }
        }
    }
    if(!contextPath.isEmpty()) {
        // If we are in a nonempty context (i.e. nested query under elemMatch), and our variable
        // refers to a field above that context, then mongo language can't handle it, and we need
        // to convert to JS
        FieldTreeNode trc=fieldNode.getParent();
        boolean fieldIsUnderContext=false;
        while(trc!=null) {
            if(trc==context) {
                fieldIsUnderContext=true;
                break;
            } else {
                trc=trc.getParent();
            }
        }
        if(!fieldIsUnderContext)
            throw new NeedsJS();
    }
    return new FieldInfo(s==null?p.immutableCopy():s.immutableCopy(),fieldNode);
}