Initial upgrade to TP3 of core Titan classes. Does not build yet (int…

…ermediate commit).

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

@@ -2,6 +2,8 @@
 
 // TODO is this vestigial now that TP3's VertexProperty.Cardinality exists?
 
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
+
 /**
  * The cardinality of the values associated with given key for a particular element.
  *
@@ -25,5 +27,23 @@ public enum Cardinality {
      */
     SET;
 
+    public org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality convert() {
+        switch (this) {
+            case SINGLE: return VertexProperty.Cardinality.single;
+            case LIST: return VertexProperty.Cardinality.list;
+            case SET: return VertexProperty.Cardinality.set;
+            default: throw new AssertionError("Unrecognized cardinality: " + this);
+        }
+    }
+
+    public static Cardinality convert(org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality cardinality) {
+        switch (cardinality) {
+            case single: return SINGLE;
+            case list: return LIST;
+            case set: return SET;
+            default: throw new AssertionError("Unrecognized cardinality: " + cardinality);
+        }
+    }
+
 
 }

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

@@ -52,7 +52,7 @@ public interface TitanTransaction extends TitanGraphTransaction {
     /**
      * Retrieves the vertex for the specified id.
      *
-     * This method is intended for internal use only. Use {@link com.tinkerpop.gremlin.structure.Graph#V(Object...)} instead.
+     * This method is intended for internal use only. Use {@link org.apache.tinkerpop.gremlin.structure.Graph#vertices(Object...)} instead.
      *
      * @param id id of the vertex to retrieve
      * @return vertex with the given id if it exists, else null

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

@@ -258,19 +258,19 @@ private synchronized void closeInternal() {
         }
     }
 
-private synchronized void removeHook() {
-    if (null == shutdownHook)
-            return;
-
-    ShutdownThread tmp = shutdownHook;
-    shutdownHook = null;
-    // Remove shutdown hook to avoid reference retention
-    try {
-        Runtime.getRuntime().removeShutdownHook(tmp);
-    } catch (IllegalStateException e) {
-        log.warn("Failed to remove shutdown hook", e);
+    private synchronized void removeHook() {
+        if (null == shutdownHook)
+                return;
+
+        ShutdownThread tmp = shutdownHook;
+        shutdownHook = null;
+        // Remove shutdown hook to avoid reference retention
+        try {
+            Runtime.getRuntime().removeShutdownHook(tmp);
+        } catch (IllegalStateException e) {
+            log.warn("Failed to remove shutdown hook", e);
+        }
     }
-}
 
 
     // ################### Simple Getters #########################

titan-core/src/main/java/com/thinkaurelius/titan/graphdb/olap/computer/FulgoraGraphComputer.java

@@ -14,6 +14,7 @@
 import com.thinkaurelius.titan.diskstorage.keycolumnvalue.scan.StandardScanner;
 import com.thinkaurelius.titan.graphdb.configuration.GraphDatabaseConfiguration;
 import com.thinkaurelius.titan.graphdb.database.StandardTitanGraph;
+import org.apache.tinkerpop.gremlin.process.computer.util.DefaultComputerResult;
 import org.apache.tinkerpop.gremlin.process.traversal.Traversal;
 import org.apache.tinkerpop.gremlin.process.traversal.TraversalSideEffects;
 import org.apache.tinkerpop.gremlin.process.computer.ComputerResult;
@@ -24,6 +25,7 @@
 import org.apache.tinkerpop.gremlin.process.computer.util.GraphComputerHelper;
 import org.apache.tinkerpop.gremlin.structure.Graph;
 import org.apache.tinkerpop.gremlin.structure.Vertex;
+import org.apache.tinkerpop.gremlin.structure.VertexProperty;
 import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -267,9 +269,9 @@ public Map<String,Object> apply(@Nullable Map<String,Object> o) {
                 } else if (resultMode==ResultMode.LOCALTX) {
                     resultgraph = graph.newTransaction();
                     for (Map.Entry<Long, Map<String, Object>> vprop : mutatedProperties.entrySet()) {
-                        Vertex v = resultgraph.V(vprop.getKey()).next();
+                        Vertex v = resultgraph.vertices(vprop.getKey()).next();
                         for (Map.Entry<String,Object> prop : vprop.getValue().entrySet()) {
-                            v.singleProperty(prop.getKey(),prop.getValue());
+                            v.property(VertexProperty.Cardinality.single,prop.getKey(), prop.getValue());
                         }
                     }
                 }
@@ -278,7 +280,7 @@ public Map<String,Object> apply(@Nullable Map<String,Object> o) {
             // update runtime and return the newly computed graph
             this.memory.setRuntime(System.currentTimeMillis() - time);
             this.memory.complete();
-            return new ComputerResult(resultgraph, this.memory);
+            return new DefaultComputerResult(resultgraph, this.memory);
         });
     }
 
@@ -301,7 +303,7 @@ public void run() {
                 for (Map.Entry<Long, Map<String, Object>> vprop : properties) {
                     Vertex v = tx.getVertex(vprop.getKey());
                     for (Map.Entry<String,Object> prop : vprop.getValue().entrySet()) {
-                        v.singleProperty(prop.getKey(),prop.getValue());
+                        v.property(VertexProperty.Cardinality.single,prop.getKey(), prop.getValue());
                     }
                 }
                 tx.commit();
@@ -324,8 +326,8 @@ public String toString() {
     public Features features() {
         return new Features() {
             @Override
-            public boolean supportsWorkerPersistenceBetweenIterations() {
-                return false;
+            public boolean supportsResultGraphPersistCombination(final ResultGraph resultGraph, final Persist persist) {
+                //?
             }
 
             @Override

titan-core/src/main/java/com/thinkaurelius/titan/graphdb/olap/computer/VertexMemoryHandler.java

@@ -44,7 +44,7 @@ <V> TitanVertexProperty<V> constructProperty(String key, V value) {
     }
 
     @Override
-    public <V> Iterator<VertexProperty<V>> propertyIterator(String... keys) {
+    public <V> Iterator<VertexProperty<V>> properties(String... keys) {
         if (vertexMemory.elementKeyMap.isEmpty()) return Collections.emptyIterator();
         if (keys==null || keys.length==0) {
             return Collections.emptyIterator(); //Do NOT return compute keys as part of all the properties...
@@ -66,14 +66,10 @@ public boolean supports(String key) {
     }
 
     @Override
-    public <V> TitanVertexProperty<V> property(String key, V value) {
-        return singleProperty(key,value);
-    }
-
-    @Override
-    public <V> TitanVertexProperty<V> singleProperty(String key, V value) {
+    public <V> TitanVertexProperty<V> property(VertexProperty.Cardinality cardinality, String key, V value) {
         if (!supports(key)) throw GraphComputer.Exceptions.providedKeyIsNotAnElementComputeKey(key);
         Preconditions.checkArgument(value != null);
+        Preconditions.checkArgument(cardinality== VertexProperty.Cardinality.single,"Only single cardinality is supported, provided: %s",cardinality);
         vertexMemory.setProperty(vertexId, key, value);
         return constructProperty(key,value);
     }

titan-core/src/main/java/com/thinkaurelius/titan/graphdb/olap/computer/VertexProgramScanJob.java

@@ -29,6 +29,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -99,7 +100,8 @@ public void process(TitanVertex vertex, ScanMetrics metrics) {
             for (MessageScope scope : scopes) {
                 if (scope instanceof MessageScope.Local) {
                     M combinedMsg = null;
-                    for (M msg : vh.receiveMessages(scope)) {
+                    for (Iterator<M> msgIter = vh.receiveMessages(scope); msgIter.hasNext(); ) {
+                        M msg = msgIter.next();
                         if (combinedMsg==null) combinedMsg=msg;
                         else combinedMsg = combiner.combine(combinedMsg,msg);
                     }

titan-core/src/main/java/com/thinkaurelius/titan/graphdb/tinkerpop/TitanBlueprintsGraph.java

@@ -16,16 +16,14 @@
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
 import org.apache.tinkerpop.gremlin.structure.*;
 import org.apache.tinkerpop.gremlin.structure.io.DefaultIo;
+import org.apache.tinkerpop.gremlin.structure.util.AbstractTransaction;
 import org.apache.tinkerpop.gremlin.structure.util.StringFactory;
 import org.apache.commons.configuration.Configuration;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Collection;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -42,10 +40,7 @@ public abstract class TitanBlueprintsGraph implements TitanGraph {
             LoggerFactory.getLogger(TitanBlueprintsGraph.class);
 
 
-    @Override
-    public Io io() {
-        return new TitanIo(this);
-    }
+
 
     // ########## TRANSACTION HANDLING ###########################
 
@@ -67,7 +62,7 @@ private TitanBlueprintsTransaction getAutoStartTx() {
 
         TitanBlueprintsTransaction tx = txs.get();
         Preconditions.checkState(tx!=null,"Invalid read-write behavior configured: " +
-                "Should either open transaction or throw exception. [%s]",tinkerpopTxContainer.readWriteBehavior);
+                "Should either open transaction or throw exception.");
         return tx;
     }
 
@@ -112,6 +107,11 @@ public Configuration configuration() {
         return config.getLocalConfiguration();
     }
 
+    @Override
+    public Io io() {
+        return new TitanIo(this);
+    }
+
     // ########## TRANSACTIONAL FORWARDING ###########################
 
     @Override
@@ -125,27 +125,30 @@ public TitanVertex addVertex(Object... keyValues) {
 //    }
 
     @Override
-    public GraphTraversal<Vertex, Vertex> V(Object... ids) {
-        return getAutoStartTx().V(ids);
+    public Iterator<Vertex> vertices(Object... vertexIds) {
+        return getAutoStartTx().vertices(vertexIds);
     }
 
     @Override
-    public GraphTraversal<Edge, Edge> E(Object... ids) {
-        return getAutoStartTx().E(ids);
+    public Iterator<Edge> edges(Object... edgeIds) {
+        return getAutoStartTx().edges(edgeIds);
     }
 
     @Override
-    public TitanGraphComputer compute(final Class... graphComputerClass) {
-        if (graphComputerClass.length > 1)
-            throw Graph.Exceptions.onlyOneOrNoGraphComputerClass();
-        if (graphComputerClass.length == 0 || graphComputerClass[0].equals(FulgoraGraphComputer.class)) {
-            StandardTitanGraph graph = (StandardTitanGraph)this;
-            return new FulgoraGraphComputer(graph,graph.getConfiguration().getConfiguration());
+    public <C extends GraphComputer> C compute(Class<C> graphComputerClass) throws IllegalArgumentException {
+        if (!graphComputerClass.equals(FulgoraGraphComputer.class)) {
+            throw Graph.Exceptions.graphDoesNotSupportProvidedGraphComputer(graphComputerClass);
         } else {
-            throw Graph.Exceptions.graphDoesNotSupportProvidedGraphComputer(graphComputerClass[0]);
+            return (C)compute();
         }
     }
 
+    @Override
+    public FulgoraGraphComputer compute() throws IllegalArgumentException {
+        StandardTitanGraph graph = (StandardTitanGraph)this;
+        return new FulgoraGraphComputer(graph,graph.getConfiguration().getConfiguration());
+    }
+
     @Override
     public TitanVertex addVertex(String vertexLabel) {
         return getAutoStartTx().addVertex(vertexLabel);
@@ -246,32 +249,27 @@ public VertexLabel getOrCreateVertexLabel(String name) {
 
 
 
-    class GraphTransaction implements Transaction {
+    class GraphTransaction extends AbstractTransaction {
 
-        private Consumer<Transaction> readWriteBehavior = READ_WRITE_BEHAVIOR.AUTO;
-        private Consumer<Transaction> closeBehavior = CLOSE_BEHAVIOR.COMMIT;
+        public GraphTransaction() {
+            super(TitanBlueprintsGraph.this);
+        }
 
         @Override
-        public void open() {
-            if (isOpen()) throw Exceptions.transactionAlreadyOpen();
+        public void doOpen() {
             startNewTx();
         }
 
         @Override
-        public void commit() {
+        public void doCommit() {
             getAutoStartTx().commit();
         }
 
         @Override
-        public void rollback() {
+        public void doRollback() {
             getAutoStartTx().rollback();
         }
 
-        @Override
-        public <R> Workload<R> submit(Function<Graph, R> graphRFunction) {
-            return new Workload<R>(TitanBlueprintsGraph.this,graphRFunction);
-        }
-
         @Override
         public TitanTransaction create() {
             return newTransaction();
@@ -283,37 +281,28 @@ public boolean isOpen() {
             return tx!=null && tx.isOpen();
         }
 
-        @Override
-        public void readWrite() {
-            readWriteBehavior.accept(this);
-        }
-
         @Override
         public void close() {
             close(this);
         }
 
         void close(Transaction tx) {
-            closeBehavior.accept(tx);
-            Preconditions.checkState(!tx.isOpen(),"Invalid close behavior configured: Should close transaction. [%s]",closeBehavior);
+            closeConsumer.accept(tx);
+            Preconditions.checkState(!tx.isOpen(),"Invalid close behavior configured: Should close transaction. [%s]",closeConsumer);
         }
 
         @Override
         public Transaction onReadWrite(Consumer<Transaction> transactionConsumer) {
-            if (transactionConsumer==null) throw Exceptions.onReadWriteBehaviorCannotBeNull();
             Preconditions.checkArgument(transactionConsumer instanceof READ_WRITE_BEHAVIOR,
                     "Only READ_WRITE_BEHAVIOR instances are accepted argument, got: %s", transactionConsumer);
-            this.readWriteBehavior = transactionConsumer;
-            return this;
+            return super.onReadWrite(transactionConsumer);
         }
 
         @Override
         public Transaction onClose(Consumer<Transaction> transactionConsumer) {
-            if (transactionConsumer==null) throw Exceptions.onCloseBehaviorCannotBeNull();
             Preconditions.checkArgument(transactionConsumer instanceof CLOSE_BEHAVIOR,
                     "Only CLOSE_BEHAVIOR instances are accepted argument, got: %s", transactionConsumer);
-            this.closeBehavior = transactionConsumer;
-            return this;
+            return super.onClose(transactionConsumer);
         }
     }