package com.thinkaurelius.faunus.formats.titan;
import com.google.common.base.Preconditions;
import com.thinkaurelius.faunus.FaunusEdge;
import com.thinkaurelius.faunus.FaunusVertex;
import com.thinkaurelius.titan.core.TitanType;
import com.thinkaurelius.titan.diskstorage.StaticBuffer;
import com.thinkaurelius.titan.graphdb.database.idhandling.IDHandler;
import com.thinkaurelius.titan.graphdb.types.system.SystemKey;
import com.thinkaurelius.titan.graphdb.types.system.SystemType;
import com.tinkerpop.blueprints.Direction;
import com.tinkerpop.blueprints.util.ExceptionFactory;
import java.util.HashMap;
import java.util.Map;
/**
* Creates a FaunusVertex given a TitanVertex reference.
*
* @author Matthias Broecheler (me@matthiasb.com)
* @author Marko A. Rodriguez (marko@markorodriguez.com)
*/
public class FaunusVertexLoader {
// private final boolean filterSystemTypes = true;
private final FaunusVertex vertex;
private boolean isSystemType = false;
public FaunusVertexLoader(final StaticBuffer key) {
this(IDHandler.getKeyID(key));
}
public FaunusVertexLoader(final long id) {
Preconditions.checkArgument(id > 0);
this.vertex = new FaunusVertex(id);
}
public FaunusVertex getVertex() {
return this.isSystemType ? null : this.vertex;
}
public RelationFactory getFactory() {
return new RelationFactory();
}
public class RelationFactory implements com.thinkaurelius.titan.graphdb.database.RelationFactory {
private final Map<String, Object> properties = new HashMap<String, Object>();
private Direction direction;
private TitanType type;
private long relationID;
private long otherVertexID;
private Object value;
@Override
public long getVertexID() {
return vertex.getIdAsLong();
}
@Override
public void setDirection(final Direction direction) {
this.direction = direction;
}
@Override
public void setType(final TitanType type) {
if (type == SystemKey.TypeClass) isSystemType = true;
this.type = type;
}
@Override
public void setRelationID(final long relationID) {
this.relationID = relationID;
}
@Override
public void setOtherVertexID(final long vertexId) {
this.otherVertexID = vertexId;
}
@Override
public void setValue(final Object value) {
this.value = value;
}
@Override
public void addProperty(final TitanType type, final Object value) {
properties.put(type.getName(), value);
}
public void build() {
if (this.type instanceof SystemType) return;
if (this.type.isPropertyKey()) {
Preconditions.checkNotNull(value);
vertex.setProperty(this.type.getName(), this.value);
} else {
Preconditions.checkArgument(this.type.isEdgeLabel());
FaunusEdge edge = null;
if (this.direction.equals(Direction.IN))
edge = new FaunusEdge(this.relationID, this.otherVertexID, getVertexID(), this.type.getName());
else if (this.direction.equals(Direction.OUT))
edge = new FaunusEdge(this.relationID, getVertexID(), this.otherVertexID, this.type.getName());
else if (this.direction.equals(Direction.BOTH))
throw ExceptionFactory.bothIsNotSupported();
if (null != edge) {
// load edge properties
for (final Map.Entry<String, Object> entry : this.properties.entrySet()) {
if (entry.getValue() != null) {
edge.setProperty(entry.getKey(), entry.getValue());
}
}
vertex.addEdge(this.direction, edge);
}
}
}
}
}