Java RelationTypeMetadata.Direction方法代码示例

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public boolean hasSingleRelation(DuctileVertex source, RelationTypeMetadata<DuctileEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction) {
String label = metadata.getDatastoreMetadata().getDiscriminator();
long count;
switch (direction) {
case FROM:
    count = graph.traversal().V(source.id()).outE(label).count().next();
    break;
case TO:
    count = graph.traversal().V(source.id()).inE(label).count().next();
    break;
default:
    throw new XOException("Unkown direction '" + direction.name() + "'.");
}
if (count > 1) {
    throw new XOException("Multiple results are available.");
}
return count == 1;
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public DuctileEdge getSingleRelation(DuctileVertex source, RelationTypeMetadata<DuctileEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction) {
String descriminator = metadata.getDatastoreMetadata().getDiscriminator();
Iterator<Edge> edges;
switch (direction) {
case FROM:
    edges = source.edges(Direction.OUT, descriminator);
    break;
case TO:
    edges = source.edges(Direction.IN, descriminator);
    break;
default:
    throw new XOException("Unkown direction '" + direction.name() + "'.");
}
if (!edges.hasNext()) {
    throw new XOException("No result is available.");
}
DuctileEdge result = (DuctileEdge) edges.next();
if (edges.hasNext()) {
    throw new XOException("Multiple results are available.");
}
return result;
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public Iterable<DuctileEdge> getRelations(DuctileVertex source, RelationTypeMetadata<DuctileEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction) {
String discriminator = metadata.getDatastoreMetadata().getDiscriminator();
final Iterator<Edge> edges;
switch (direction) {
case TO:
    edges = source.edges(Direction.IN, discriminator);
    break;
case FROM:
    edges = source.edges(Direction.OUT, discriminator);
    break;
default:
    throw new XOException("Unknown direction '" + direction.name() + "'.");
}
return new Iterable<DuctileEdge>() {
    @Override
    public Iterator<DuctileEdge> iterator() {
	return new CastIterator<Edge, DuctileEdge>(edges);
    }
};
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public DuctileEdge createRelation(DuctileVertex source, RelationTypeMetadata<DuctileEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction, DuctileVertex target,
    Map<PrimitivePropertyMethodMetadata<DuctilePropertyMetadata>, Object> exampleEntity) {
String name = metadata.getDatastoreMetadata().getDiscriminator();
Object[] keyValues = new Object[exampleEntity.size() * 2];
@SuppressWarnings("unchecked")
PrimitivePropertyMethodMetadata<DuctilePropertyMetadata> keys[] = exampleEntity.keySet()
	.toArray(new PrimitivePropertyMethodMetadata[exampleEntity.size()]);
for (int i = 0; i < exampleEntity.size(); ++i) {
    PrimitivePropertyMethodMetadata<DuctilePropertyMetadata> key = keys[i];
    String propertyName = key.getDatastoreMetadata().getName();
    keyValues[2 * i] = propertyName;
    keyValues[2 * i + 1] = exampleEntity.get(key);
}
switch (direction) {
case FROM:
    return source.addEdge(name, target);
case TO:
    return target.addEdge(name, source);
default:
    throw new XOException("Unknown direction '" + direction.name() + "'.");
}
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public boolean hasSingleRelation(Vertex source,
    RelationTypeMetadata<TitanEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction) {
String label = metadata.getDatastoreMetadata().getDiscriminator();
long count;
switch (direction) {
case FROM:
    count = source.query().direction(Direction.OUT).labels(label)
	    .count();
    break;
case TO:
    count = source.query().direction(Direction.IN).labels(label)
	    .count();
    break;
default:
    throw new XOException("Unkown direction '" + direction.name()
	    + "'.");
}
if (count > 1) {
    throw new XOException("Multiple results are available.");
}
return count == 1;
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public Iterable<Edge> getRelations(Vertex source,
    RelationTypeMetadata<TitanEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction) {
VertexQuery query = source.query();
String discriminator = metadata.getDatastoreMetadata()
	.getDiscriminator();
switch (direction) {
case TO:
    query = query.direction(Direction.IN).labels(discriminator);
    break;
case FROM:
    query = query.direction(Direction.OUT).labels(discriminator);
    break;
default:
    throw new XOException("Unknown direction '" + direction.name()
	    + "'.");
}
return query.edges();
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public Edge createRelation(
    Vertex source,
    RelationTypeMetadata<TitanEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction,
    Vertex target,
    Map<PrimitivePropertyMethodMetadata<TitanPropertyMetadata>, Object> exampleEntity) {
String name = metadata.getDatastoreMetadata().getDiscriminator();
switch (direction) {
case FROM:
    return source.addEdge(name, target);
case TO:
    return target.addEdge(name, source);
default:
    throw new XOException("Unknown direction '" + direction.name()
	    + "'.");
}
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
@Override
   public Edge getSingleRelation(Vertex source,
    RelationTypeMetadata<TitanEdgeMetadata> metadata,
    RelationTypeMetadata.Direction direction) {
String descriminator = metadata.getDatastoreMetadata()
	.getDiscriminator();
Iterable<Edge> edges;
switch (direction) {
case FROM:
    edges = source.getEdges(Direction.OUT, descriminator);
    break;
case TO:
    edges = source.getEdges(Direction.IN, descriminator);
    break;
default:
    throw new XOException("Unkown direction '" + direction.name()
	    + "'.");
}
Iterator<Edge> iterator = edges.iterator();
if (!iterator.hasNext()) {
    throw new XOException("No result is available.");
}
Edge result = iterator.next();
if (iterator.hasNext()) {
    throw new XOException("Multiple results are available.");
}
return result;
   }
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
private Entity getReferencedEntity(Relation relation, RelationTypeMetadata.Direction direction) {
    DatastoreRelationManager<Entity, ?, Relation, ? extends DatastoreRelationMetadata<?>, ?, ?> relationManager = sessionContext.getDatastoreSession()
            .getDatastoreRelationManager();
    switch (direction) {
    case FROM:
        return relationManager.getTo(relation);
    case TO:
        return relationManager.getFrom(relation);
    default:
        throw new XOException("Unsupported direction: " + direction);
    }
}
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
private Relation createReference(Entity sourceEntity, RelationTypeMetadata metadata, RelationTypeMetadata.Direction direction, Entity targetEntity,
        Map<PrimitivePropertyMethodMetadata<PropertyMetadata>, Object> example) {
    DatastoreRelationManager<Entity, ?, Relation, ?, ?, PropertyMetadata> datastoreRelationManager = sessionContext.getDatastoreSession()
            .getDatastoreRelationManager();
    Relation relation = (Relation) datastoreRelationManager.createRelation(sourceEntity, metadata, direction, targetEntity, example);
    AbstractInstanceManager<?, Entity> entityInstanceManager = sessionContext.getEntityInstanceManager();
    entityInstanceManager.updateInstance(sourceEntity);
    entityInstanceManager.updateInstance(targetEntity);
    return relation;
}
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
private EmbeddedDirection getDirection(RelationTypeMetadata.Direction direction) {
    switch (direction) {
    case FROM:
        return EmbeddedDirection.OUTGOING;
    case TO:
        return EmbeddedDirection.INCOMING;
    default:
        throw new XOException("Unsupported direction " + direction);
    }
}
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
private Entity getReferencedEntity(Relation relation, RelationTypeMetadata.Direction direction) {
    DatastoreRelationManager<Entity, ?, Relation, ? extends DatastoreRelationMetadata<?>, ?, ?> relationManager = sessionContext.getDatastoreSession().getDatastoreRelationManager();
    switch (direction) {
        case TO:
            return relationManager.getTo(relation);
        case FROM:
            return relationManager.getFrom(relation);
        default:
            throw direction.createNotSupportedException();
    }
}
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
private Set<RemoteRelationship> getSingleRelationship(RemoteNode source, RelationTypeMetadata<RelationshipMetadata<RemoteRelationshipType>> metadata,
        RelationTypeMetadata.Direction direction) {
    Set<RemoteRelationship> relationships = getRelationships(source, metadata.getDatastoreMetadata().getDiscriminator(), getRemoteDirection(direction))
            .getElements();
    if (relationships.size() > 1) {
        throw new XOException("Found more than one relationship for node=" + source + ", type=" + metadata.getDatastoreMetadata().getDiscriminator()
                + ", direction=" + direction + ", relationships=" + relationships);
    }
    return relationships;
}
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
private RemoteDirection getRemoteDirection(RelationTypeMetadata.Direction direction) {
    switch (direction) {
    case FROM:
        return RemoteDirection.OUTGOING;
    case TO:
        return RemoteDirection.INCOMING;
    default:
        throw new XOException("Direction not supported " + direction);
    }
}
 

import com.buschmais.xo.spi.metadata.type.RelationTypeMetadata; //导入方法依赖的package包/类
/**
 * Initializes all relation properties of the given node state with empty
 * collections.
 *
 * @param types
 *            The types.
 * @param nodeState
 *            The state of the entity.
 */
private void initializeEntity(Collection<? extends TypeMetadata> types, NodeState nodeState) {
    for (TypeMetadata type : types) {
        Collection<TypeMetadata> superTypes = type.getSuperTypes();
        initializeEntity(superTypes, nodeState);
        for (MethodMetadata<?, ?> methodMetadata : type.getProperties()) {
            if (methodMetadata instanceof AbstractRelationPropertyMethodMetadata) {
                AbstractRelationPropertyMethodMetadata<?> relationPropertyMethodMetadata = (AbstractRelationPropertyMethodMetadata) methodMetadata;
                RelationTypeMetadata<RelationshipMetadata<RemoteRelationshipType>> relationshipMetadata = relationPropertyMethodMetadata
                        .getRelationshipMetadata();
                RemoteRelationshipType relationshipType = relationshipMetadata.getDatastoreMetadata().getDiscriminator();
                RelationTypeMetadata.Direction direction = relationPropertyMethodMetadata.getDirection();
                RemoteDirection remoteDirection;
                switch (direction) {
                case FROM:
                    remoteDirection = RemoteDirection.OUTGOING;
                    break;
                case TO:
                    remoteDirection = RemoteDirection.INCOMING;
                    break;
                default:
                    throw new XOException("Unsupported direction: " + direction);
                }
                if (nodeState.getRelationships(remoteDirection, relationshipType) == null) {
                    nodeState.setRelationships(remoteDirection, relationshipType, new StateTracker<>(new LinkedHashSet<>()));
                }
            }
        }
    }
}