Java Direction.BOTH属性代码示例

/**
 * Retrieves the titan direction corresponding to the given
 * AtlasEdgeDirection.
 *
 * @param dir
 * @return
 */
public static Direction createDirection(AtlasEdgeDirection dir) {

    switch(dir) {
    case IN:
        return Direction.IN;
    case OUT:
        return Direction.OUT;
    case BOTH:
        return Direction.BOTH;
    default:
        throw new RuntimeException("Unrecognized direction: " + dir);
    }
}
 

@Override
public boolean evaluate(E element) {
    if (direction==Direction.BOTH) return true;
    if (element instanceof CacheEdge) {
        return direction==((CacheEdge)element).getVertexCentricDirection();
    } else if (element instanceof TitanEdge) {
        return ((TitanEdge)element).getVertex(direction).equals(baseVertex);
    } else if (element instanceof TitanProperty) {
        return direction==Direction.OUT;
    }
    return false;
}
 

@Override
public Direction getDirection() {
    if (type.isUnidirected(Direction.BOTH)) return Direction.BOTH;
    else if (type.isUnidirected(Direction.OUT)) return Direction.OUT;
    else if (type.isUnidirected(Direction.IN)) return Direction.IN;
    throw new AssertionError();
}
 

protected Iterable<FaunusRelation> getRelations(FaunusElement element, RelationCategory returnType) {
    FaunusSchemaManager typeManager = element.getTypeManager();

    final And<TitanRelation> condition = getCondition(element,returnType);
    if (condition==null) return Collections.EMPTY_LIST;

    Iterable<FaunusRelation> result=null;
    for (Direction direction : Direction.proper) {
        if (dir!=direction && dir!=Direction.BOTH) continue;

        SetMultimap<FaunusRelationType, FaunusRelation> adjacency = element.getAdjacency(direction);
        if (types.length==0) {
            if (result==null) result=adjacency.values();
            else result = Iterables.concat(result,adjacency.values());
        } else {
            for (String type : types) {
                FaunusRelationType rt = typeManager.getRelationType(type);
                if (rt==null) continue;
                Iterable<FaunusRelation> rels;
                if (rt.isPropertyKey() && ((FaunusPropertyKey)rt).isImplicit()) {
                    FaunusPropertyKey key = (FaunusPropertyKey)rt;
                    Object value = key.computeImplicit(element);
                    if (value!=null)
                        rels = Lists.newArrayList((FaunusRelation)new SimpleFaunusProperty(key,value));
                    else rels = Collections.EMPTY_LIST;
                } else {
                    rels = adjacency.get(rt);
                }
                if (result==null) result=rels;
                else result = Iterables.concat(result,rels);
            }
        }
    }

    result = new FilterIterable(condition, element, result, dir);

    //Order
    if (!orders.isEmpty()) {
        ArrayList<FaunusRelation> allRels = Lists.newArrayList(result);
        Collections.sort(allRels,orders);
        result = new RemoveOriginalIterable(allRels, element, dir);
    }
    //Limit
    if (limit!= Query.NO_LIMIT) {
        result = Iterables.limit(result,limit);
    }

    return result;
}
 

protected void initializeAdjacency(Direction dir) {
    if ((dir==Direction.OUT || dir==Direction.BOTH) && this.outAdjacency == EMPTY_ADJACENCY)
        outAdjacency = HashMultimap.create();
    if ((dir==Direction.IN || dir==Direction.BOTH) && this.inAdjacency == EMPTY_ADJACENCY)
        inAdjacency = HashMultimap.create();
}
 

/**
 * Construct an empty query
 */
protected BaseVertexCentricQuery() {
    this(new FixedCondition<TitanRelation>(false), Direction.BOTH, new ArrayList<BackendQueryHolder<SliceQuery>>(0),OrderList.NO_ORDER,0);
}
 

public StandardEdgeLabelMaker(StandardTitanTx tx, IndexSerializer indexSerializer,
                              final AttributeHandling attributeHandler) {
    super(tx, indexSerializer, attributeHandler);
    unidirectionality = Direction.BOTH;
}
 

@Override
public StandardEdgeLabelMaker directed() {
    unidirectionality = Direction.BOTH;
    return this;
}
 

@Override
public boolean isUnidirected(Direction dir) {
    if (unidirected) return dir==Direction.OUT;
    else return dir==Direction.BOTH;
}
 

public static boolean impliedBy(Direction sub, Direction sup) {
    return sup==sub || sup==Direction.BOTH;
}