Java Direction.IN属性代码示例

/**
 * 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);
    }
}
 

public FaunusEdge addEdge(final Direction direction, final String label, final long otherVertexId) {
    if (direction == OUT)
        return this.addEdge(new StandardFaunusEdge(this.configuration, getLongId(), otherVertexId, label));
    else if (direction == Direction.IN)
        return this.addEdge(new StandardFaunusEdge(this.configuration, otherVertexId, getLongId(), label));
    else
        throw ExceptionFactory.bothIsNotSupported();
}
 

@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();
}
 

public Direction getDirection() {
    switch(this) {
        case PROPERTY_DIR:
        case EDGE_OUT_DIR:
            return Direction.OUT;
        case EDGE_IN_DIR:
            return Direction.IN;
        default: throw new AssertionError();
    }
}
 

TitanRelation findRelation(TitanTransaction tx) {
    TitanVertex v = ((StandardTitanTx)tx).getInternalVertex(outVertexId);
    if (v == null || v.isRemoved()) return null;
    TitanVertex typeVertex = tx.getVertex(typeId);
    if (typeVertex == null) return null;
    if (!(typeVertex instanceof RelationType))
        throw new IllegalArgumentException("Invalid RelationIdentifier: typeID does not reference a type");

    RelationType type = (RelationType)typeVertex;
    Iterable<? extends TitanRelation> rels;
    if (((RelationType) typeVertex).isEdgeLabel()) {
        Direction dir = Direction.OUT;
        TitanVertex other = ((StandardTitanTx)tx).getInternalVertex(inVertexId);
        if (other==null || other.isRemoved()) return null;
        if (((StandardTitanTx)tx).isPartitionedVertex(v) && !((StandardTitanTx)tx).isPartitionedVertex(other)) { //Swap for likely better performance
            TitanVertex tmp = other;
            other = v;
            v = tmp;
            dir = Direction.IN;
        }
        rels = ((VertexCentricQueryBuilder)v.query()).noPartitionRestriction().types((EdgeLabel) type).direction(dir).adjacent(other).titanEdges();
    } else {
        rels = ((VertexCentricQueryBuilder)v.query()).noPartitionRestriction().types((PropertyKey)type).properties();
    }

    for (TitanRelation r : rels) {
        //Find current or previous relation
        if (r.getLongId() == relationId ||
                ((r instanceof StandardRelation) && ((StandardRelation)r).getPreviousID()==relationId)) return r;
    }
    return null;
}
 

public static Direction fromPosition(int pos) {
    switch (pos) {
        case 0:
            return Direction.OUT;

        case 1:
            return Direction.IN;

        default:
            throw new IllegalArgumentException("Invalid position:" + pos);
    }
}
 

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();
}
 

@Override
public TitanVertex getVertex(Direction dir) {
    if (dir!=Direction.IN) throw new UnsupportedOperationException();
    return vertex;
}
 

@Override
public long getVertexId(Direction dir) {
    if (dir!=Direction.IN) throw new UnsupportedOperationException();
    return vertex.getLongId();
}
 

public static boolean isProperDirection(Direction dir) {
    return dir==Direction.IN || dir==Direction.OUT;
}