Fixes #860 which entailed a lot of refactoring of existing core and i…

…nternal interfaces with changes throughout the codebase.

titan-core/src/main/java/com/thinkaurelius/titan/core/TitanElement.java

@@ -93,15 +93,15 @@ public default Object id() {
     public<V> Property<V> property(String key, V value);
 
     /**
-     * Retrieves the value associated with the given key on this vertex and casts it to the specified type.
+     * Retrieves the value associated with the given key on this element and casts it to the specified type.
      * If the key has cardinality SINGLE, then there can be at most one value and this value is returned (or null).
      * Otherwise a list of all associated values is returned, or an empty list if non exist.
      * <p/>
      *
      * @param key key
      * @return value or list of values associated with key
      */
-    public <V> V valueOrNull(RelationType key);
+    public <V> V valueOrNull(PropertyKey key);
 
     //########### LifeCycle Status ##########
 

titan-core/src/main/java/com/thinkaurelius/titan/core/TitanProperty.java

@@ -1,18 +1,17 @@
 package com.thinkaurelius.titan.core;
 
-import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.structure.Property;
 
 /**
  * @author Matthias Broecheler (me@matthiasb.com)
  */
 public interface TitanProperty<V> extends Property<V> {
 
-    public RelationType getType();
+    public PropertyKey propertyKey();
 
     @Override
     public default String key() {
-        return getType().name();
+        return propertyKey().name();
     }
 
 }

titan-core/src/main/java/com/thinkaurelius/titan/core/TitanVertexProperty.java

@@ -26,11 +26,7 @@ public default TitanTransaction graph() {
         return element().graph();
     }
 
-    /**
-     * Returns the {@link PropertyKey} for this property
-     * 
-     * @return
-     */
+    @Override
     public default PropertyKey propertyKey() {
         return (PropertyKey)getType();
     }

titan-core/src/main/java/com/thinkaurelius/titan/core/schema/EdgeLabelMaker.java

@@ -2,6 +2,7 @@
 
 import com.thinkaurelius.titan.core.EdgeLabel;
 import com.thinkaurelius.titan.core.Multiplicity;
+import com.thinkaurelius.titan.core.PropertyKey;
 import com.thinkaurelius.titan.core.RelationType;
 
 /**
@@ -42,7 +43,7 @@ public interface EdgeLabelMaker extends RelationTypeMaker {
 
 
     @Override
-    public EdgeLabelMaker signature(RelationType... types);
+    public EdgeLabelMaker signature(PropertyKey... types);
 
 
     /**

titan-core/src/main/java/com/thinkaurelius/titan/core/schema/PropertyKeyMaker.java

@@ -38,7 +38,7 @@ public interface PropertyKeyMaker extends RelationTypeMaker {
     public PropertyKeyMaker dataType(Class<?> clazz);
 
     @Override
-    public PropertyKeyMaker signature(RelationType... types);
+    public PropertyKeyMaker signature(PropertyKey... types);
 
 
     /**

titan-core/src/main/java/com/thinkaurelius/titan/core/schema/RelationTypeMaker.java

@@ -1,5 +1,6 @@
 package com.thinkaurelius.titan.core.schema;
 
+import com.thinkaurelius.titan.core.PropertyKey;
 import com.thinkaurelius.titan.core.RelationType;
 
 /**
@@ -39,10 +40,10 @@ public interface RelationTypeMaker {
      * <br />
      * The signature is empty by default.
      *
-     * @param types RelationTypes composing the signature for the configured relation type. The order is irrelevant.
+     * @param keys PropertyKey composing the signature for the configured relation type. The order is irrelevant.
      * @return this RelationTypeMaker
      */
-    public RelationTypeMaker signature(RelationType... types);
+    public RelationTypeMaker signature(PropertyKey... keys);
 
     /**
      * Builds the configured relation type

titan-core/src/main/java/com/thinkaurelius/titan/core/schema/TitanManagement.java

@@ -37,7 +37,7 @@ public interface TitanManagement extends TitanConfiguration, SchemaManager {
      */
 
     /**
-     * Identical to {@link #buildEdgeIndex(com.thinkaurelius.titan.core.EdgeLabel, String, com.tinkerpop.gremlin.structure.Direction, com.tinkerpop.gremlin.structure.Order, com.thinkaurelius.titan.core.RelationType...)}
+     * Identical to {@link #buildEdgeIndex(com.thinkaurelius.titan.core.EdgeLabel, String, com.tinkerpop.gremlin.structure.Direction, com.tinkerpop.gremlin.structure.Order, com.thinkaurelius.titan.core.PropertyKey...)}
      * with default sort order {@link com.tinkerpop.gremlin.structure.Order#incr}.
      *
      * @param label
@@ -46,7 +46,7 @@ public interface TitanManagement extends TitanConfiguration, SchemaManager {
      * @param sortKeys
      * @return the created {@link RelationTypeIndex}
      */
-    public RelationTypeIndex buildEdgeIndex(EdgeLabel label, String name, Direction direction, RelationType... sortKeys);
+    public RelationTypeIndex buildEdgeIndex(EdgeLabel label, String name, Direction direction, PropertyKey... sortKeys);
 
     /**
      * Creates a {@link RelationTypeIndex} for the provided edge label. That means, that all edges of that label will be
@@ -62,18 +62,18 @@ public interface TitanManagement extends TitanConfiguration, SchemaManager {
      * @param sortKeys
      * @return the created {@link RelationTypeIndex}
      */
-    public RelationTypeIndex buildEdgeIndex(EdgeLabel label, String name, Direction direction, Order sortOrder, RelationType... sortKeys);
+    public RelationTypeIndex buildEdgeIndex(EdgeLabel label, String name, Direction direction, Order sortOrder, PropertyKey... sortKeys);
 
     /**
-     * Identical to {@link #buildPropertyIndex(com.thinkaurelius.titan.core.PropertyKey, String, com.tinkerpop.gremlin.structure.Order, com.thinkaurelius.titan.core.RelationType...)}
+     * Identical to {@link #buildPropertyIndex(com.thinkaurelius.titan.core.PropertyKey, String, com.tinkerpop.gremlin.structure.Order, com.thinkaurelius.titan.core.PropertyKey...)}
      * with default sort order {@link com.tinkerpop.gremlin.structure.Order#incr}.
      *
      * @param key
      * @param name
      * @param sortKeys
      * @return the created {@link RelationTypeIndex}
      */
-    public RelationTypeIndex buildPropertyIndex(PropertyKey key, String name, RelationType... sortKeys);
+    public RelationTypeIndex buildPropertyIndex(PropertyKey key, String name, PropertyKey... sortKeys);
 
     /**
      * Creates a {@link RelationTypeIndex} for the provided property key. That means, that all properties of that key will be
@@ -87,7 +87,7 @@ public interface TitanManagement extends TitanConfiguration, SchemaManager {
      * @param sortKeys
      * @return the created {@link RelationTypeIndex}
      */
-    public RelationTypeIndex buildPropertyIndex(PropertyKey key, String name, Order sortOrder, RelationType... sortKeys);
+    public RelationTypeIndex buildPropertyIndex(PropertyKey key, String name, Order sortOrder, PropertyKey... sortKeys);
 
     /**
      * Whether a {@link RelationTypeIndex} with the given name has been defined for the provided {@link RelationType}

titan-core/src/main/java/com/thinkaurelius/titan/graphdb/database/EdgeSerializer.java

@@ -33,7 +33,7 @@
 import java.util.Map;
 
 import static com.thinkaurelius.titan.graphdb.database.idhandling.IDHandler.DirectionID;
-import static com.thinkaurelius.titan.graphdb.database.idhandling.IDHandler.EdgeTypeParse;
+import static com.thinkaurelius.titan.graphdb.database.idhandling.IDHandler.RelationTypeParse;
 import static com.thinkaurelius.titan.graphdb.database.idhandling.IDHandler.getBounds;
 
 /**
@@ -66,15 +66,15 @@ public RelationCache readRelation(Entry data, boolean parseHeaderOnly, TypeInspe
     public Direction parseDirection(Entry data) {
         RelationCache map = data.getCache();
         if (map != null) return map.direction;
-        return IDHandler.readEdgeType(data.asReadBuffer()).dirID.getDirection();
+        return IDHandler.readRelationType(data.asReadBuffer()).dirID.getDirection();
     }
 
     @Override
     public RelationCache parseRelation(Entry data, boolean excludeProperties, TypeInspector tx) {
         ReadBuffer in = data.asReadBuffer();
 
         LongObjectOpenHashMap properties = excludeProperties ? null : new LongObjectOpenHashMap(4);
-        EdgeTypeParse typeAndDir = IDHandler.readEdgeType(in);
+        RelationTypeParse typeAndDir = IDHandler.readRelationType(in);
 
         long typeId = typeAndDir.typeId;
         Direction dir = typeAndDir.dirID.getDirection();
@@ -145,7 +145,7 @@ public RelationCache parseRelation(Entry data, boolean excludeProperties, TypeIn
 
             //Third: read rest
             while (in.hasRemaining()) {
-                RelationType type = tx.getExistingRelationType(IDHandler.readInlineEdgeType(in));
+                PropertyKey type = tx.getExistingPropertyKey(IDHandler.readInlineRelationType(in));
                 Object pvalue = readInline(in, type, InlineType.NORMAL);
                 assert pvalue != null;
                 properties.put(type.longId(), pvalue);
@@ -165,27 +165,16 @@ public RelationCache parseRelation(Entry data, boolean excludeProperties, TypeIn
         return new RelationCache(dir, typeId, relationId, other, properties);
     }
 
-    private void readInlineTypes(long[] typeids, LongObjectOpenHashMap properties, ReadBuffer in, TypeInspector tx, InlineType inlineType) {
-        for (long typeid : typeids) {
-            RelationType keyType = tx.getExistingRelationType(typeid);
+    private void readInlineTypes(long[] keyIds, LongObjectOpenHashMap properties, ReadBuffer in, TypeInspector tx, InlineType inlineType) {
+        for (long keyId : keyIds) {
+            PropertyKey keyType = tx.getExistingPropertyKey(keyId);
             Object value = readInline(in, keyType, inlineType);
-            if (value != null) properties.put(typeid, value);
+            if (value != null) properties.put(keyId, value);
         }
     }
 
-    private Object readInline(ReadBuffer read, RelationType type, InlineType inlineType) {
-        if (type.isPropertyKey()) {
-            PropertyKey key = ((PropertyKey) type);
-            return readPropertyValue(read,key, inlineType);
-        } else {
-            assert type.isEdgeLabel();
-            long id;
-            if (inlineType.writeByteOrdered())
-                id = LongSerializer.INSTANCE.readByteOrder(read);
-            else
-                id = VariableLong.readPositive(read);
-            return id == 0 ? null : id;
-        }
+    private Object readInline(ReadBuffer read, PropertyKey key, InlineType inlineType) {
+        return readPropertyValue(read, key, inlineType);
     }
 
     private Object readPropertyValue(ReadBuffer read, PropertyKey key) {
@@ -239,7 +228,7 @@ public StaticArrayEntry writeRelation(InternalRelation relation, InternalRelatio
 
         DataOutput out = serializer.getDataOutput(DEFAULT_CAPACITY);
         int valuePosition;
-        IDHandler.writeEdgeType(out, typeid, dirID, type.isInvisibleType());
+        IDHandler.writeRelationType(out, typeid, dirID, type.isInvisibleType());
         Multiplicity multiplicity = type.multiplicity();
 
         long[] sortKey = type.getSortKey();
@@ -305,7 +294,7 @@ public StaticArrayEntry writeRelation(InternalRelation relation, InternalRelatio
             for (long id : signature) writtenTypes.add(id);
         }
         LongArrayList remainingTypes = new LongArrayList(8);
-        for (RelationType t : relation.getPropertyKeysDirect()) {
+        for (PropertyKey t : relation.getPropertyKeysDirect()) {
             if (!(t instanceof ImplicitKey) && !writtenTypes.contains(t.longId())) {
                 remainingTypes.add(t.longId());
             }
@@ -314,7 +303,7 @@ public StaticArrayEntry writeRelation(InternalRelation relation, InternalRelatio
         long[] remaining = remainingTypes.toArray();
         Arrays.sort(remaining);
         for (long tid : remaining) {
-            RelationType t = tx.getExistingRelationType(tid);
+            PropertyKey t = tx.getExistingPropertyKey(tid);
             writeInline(out, t, relation.getValueDirect(t), InlineType.NORMAL);
         }
         assert valuePosition>0;
@@ -329,7 +318,7 @@ private enum InlineType {
 
         KEY, SIGNATURE, NORMAL;
 
-        public boolean writeEdgeType() {
+        public boolean writeInlineKey() {
             return this==NORMAL;
         }
 
@@ -339,28 +328,21 @@ public boolean writeByteOrdered() {
 
     }
 
-    private void writeInlineTypes(long[] typeids, InternalRelation relation, DataOutput out, TypeInspector tx, InlineType inlineType) {
-        for (long typeid : typeids) {
-            RelationType t = tx.getExistingRelationType(typeid);
+    private void writeInlineTypes(long[] keyIds, InternalRelation relation, DataOutput out, TypeInspector tx, InlineType inlineType) {
+        for (long keyId : keyIds) {
+            PropertyKey t = tx.getExistingPropertyKey(keyId);
             writeInline(out, t, relation.getValueDirect(t), inlineType);
         }
     }
 
-    private void writeInline(DataOutput out, RelationType type, Object value, InlineType inlineType) {
-        assert !(type.isPropertyKey() && !inlineType.writeEdgeType()) || !AttributeUtil.hasGenericDataType((PropertyKey) type);
+    private void writeInline(DataOutput out, PropertyKey inlineKey, Object value, InlineType inlineType) {
+        assert inlineType.writeInlineKey() || !AttributeUtil.hasGenericDataType(inlineKey);
 
-        if (inlineType.writeEdgeType()) {
-            IDHandler.writeInlineEdgeType(out, type.longId());
+        if (inlineType.writeInlineKey()) {
+            IDHandler.writeInlineRelationType(out, inlineKey.longId());
         }
 
-        if (type.isPropertyKey()) {
-            writePropertyValue(out,(PropertyKey)type,value, inlineType);
-        } else {
-            assert type.isEdgeLabel() && ((EdgeLabel) type).isUnidirected();
-            long id = (value==null?0:((InternalVertex) value).longId());
-            if (inlineType.writeByteOrdered()) LongSerializer.INSTANCE.writeByteOrder(out,id);
-            else VariableLong.writePositive(out,id);
-        }
+        writePropertyValue(out,inlineKey,value, inlineType);
     }
 
     private void writePropertyValue(DataOutput out, PropertyKey key, Object value) {
@@ -394,59 +376,59 @@ public SliceQuery getQuery(InternalRelationType type, Direction dir, TypedInterv
         RelationCategory rt = type.isPropertyKey() ? RelationCategory.PROPERTY : RelationCategory.EDGE;
         if (dir == Direction.BOTH) {
             assert type.isEdgeLabel();
-            sliceStart = IDHandler.getEdgeType(type.longId(), getDirID(Direction.OUT, rt),type.isInvisibleType());
-            sliceEnd = IDHandler.getEdgeType(type.longId(), getDirID(Direction.IN, rt),type.isInvisibleType());
+            sliceStart = IDHandler.getRelationType(type.longId(), getDirID(Direction.OUT, rt), type.isInvisibleType());
+            sliceEnd = IDHandler.getRelationType(type.longId(), getDirID(Direction.IN, rt), type.isInvisibleType());
             assert sliceStart.compareTo(sliceEnd)<0;
             sliceEnd = BufferUtil.nextBiggerBuffer(sliceEnd);
         } else {
             DirectionID dirID = getDirID(dir, rt);
 
             DataOutput colStart = serializer.getDataOutput(DEFAULT_COLUMN_CAPACITY);
             DataOutput colEnd = serializer.getDataOutput(DEFAULT_COLUMN_CAPACITY);
-            IDHandler.writeEdgeType(colStart, type.longId(), dirID, type.isInvisibleType());
-            IDHandler.writeEdgeType(colEnd, type.longId(), dirID, type.isInvisibleType());
+            IDHandler.writeRelationType(colStart, type.longId(), dirID, type.isInvisibleType());
+            IDHandler.writeRelationType(colEnd, type.longId(), dirID, type.isInvisibleType());
 
             long[] sortKeyIDs = type.getSortKey();
             Preconditions.checkArgument(sortKey.length >= sortKeyIDs.length);
             assert colStart.getPosition() == colEnd.getPosition();
             int keyStartPos = colStart.getPosition();
             int keyEndPos = -1;
             for (int i = 0; i < sortKey.length && sortKey[i] != null; i++) {
-                RelationType t = sortKey[i].type;
+                PropertyKey skey = sortKey[i].key;
                 Interval interval = sortKey[i].interval;
 
                 if (i>=sortKeyIDs.length) {
                     assert !type.multiplicity().isUnique(dir);
-                    assert (t instanceof ImplicitKey) && (t==ImplicitKey.TITANID || t==ImplicitKey.ADJACENT_ID);
-                    assert t!=ImplicitKey.ADJACENT_ID || (i==sortKeyIDs.length);
-                    assert t!=ImplicitKey.TITANID || (!type.multiplicity().isConstrained() &&
-                                                  (i==sortKeyIDs.length && t.isPropertyKey() || i==sortKeyIDs.length+1 && t.isEdgeLabel() ));
+                    assert (skey instanceof ImplicitKey) && (skey==ImplicitKey.TITANID || skey==ImplicitKey.ADJACENT_ID);
+                    assert skey!=ImplicitKey.ADJACENT_ID || (i==sortKeyIDs.length);
+                    assert skey!=ImplicitKey.TITANID || (!type.multiplicity().isConstrained() &&
+                                                  (i==sortKeyIDs.length && skey.isPropertyKey() || i==sortKeyIDs.length+1 && skey.isEdgeLabel() ));
                     assert colStart.getPosition()==colEnd.getPosition();
                     assert interval==null || interval.isPoints();
                     keyEndPos = colStart.getPosition();
 
                 } else {
                     assert !type.multiplicity().isConstrained();
-                    assert t.longId() == sortKeyIDs[i];
+                    assert skey.longId() == sortKeyIDs[i];
                 }
 
                 if (interval == null || interval.isEmpty()) {
                     break;
                 }
                 if (interval.isPoints()) {
-                    if (t==ImplicitKey.TITANID || t==ImplicitKey.ADJACENT_ID) {
+                    if (skey==ImplicitKey.TITANID || skey==ImplicitKey.ADJACENT_ID) {
                         assert !type.multiplicity().isUnique(dir);
                         VariableLong.writePositiveBackward(colStart, (Long)interval.getStart());
                         VariableLong.writePositiveBackward(colEnd, (Long)interval.getEnd());
                     } else {
-                        writeInline(colStart, t, interval.getStart(), InlineType.KEY);
-                        writeInline(colEnd, t, interval.getEnd(), InlineType.KEY);
+                        writeInline(colStart, skey, interval.getStart(), InlineType.KEY);
+                        writeInline(colEnd, skey, interval.getEnd(), InlineType.KEY);
                     }
                 } else {
                     if (interval.getStart() != null)
-                        writeInline(colStart, t, interval.getStart(), InlineType.KEY);
+                        writeInline(colStart, skey, interval.getStart(), InlineType.KEY);
                     if (interval.getEnd() != null)
-                        writeInline(colEnd, t, interval.getEnd(), InlineType.KEY);
+                        writeInline(colEnd, skey, interval.getEnd(), InlineType.KEY);
 
                     switch (type.getSortOrder()) {
                         case ASC:
@@ -493,12 +475,12 @@ public SliceQuery getQuery(InternalRelationType type, Direction dir, TypedInterv
     }
 
     public static class TypedInterval {
-        public final InternalRelationType type;
+        public final PropertyKey key;
         public final Interval interval;
 
 
-        public TypedInterval(InternalRelationType type, Interval interval) {
-            this.type = type;
+        public TypedInterval(PropertyKey key, Interval interval) {
+            this.key = key;
             this.interval = interval;
         }
     }