Package org.apache.tinkerpop.gremlin.process.computer.clustering.peerpressure

Class ClusterCountMapReduce

    • Method Detail

      • loadState

        public void loadState​(Graph graph,
                      org.apache.commons.configuration2.Configuration configuration)
        Description copied from interface: MapReduce
        When it is necessary to load the state of a MapReduce job, this method is called. This is typically required when the MapReduce job needs to be serialized to another machine. Note that what is loaded is simply the instance state, not any processed data.

        It is important that the state loaded from loadState() is identical to any state created from a constructor. For those GraphComputers that do not need to use Configurations to migrate state between JVMs, the constructor will only be used.

        Parameters:
        graph - the graph the MapReduce job will run against
        configuration - the configuration to load the state of the MapReduce job from.

      • doStage

        public boolean doStage​(MapReduce.Stage stage)
        Description copied from interface: MapReduce
        A MapReduce job can be map-only, map-reduce-only, or map-combine-reduce. Before executing the particular stage, this method is called to determine if the respective stage is defined. This method should return true if the respective stage as a non-default method implementation.
        Parameters:
        stage - the stage to check for definition.
        Returns:
        whether that stage should be executed.

      • map

        public void map​(Vertex vertex,
                MapReduce.MapEmitter<MapReduce.NullObject,​Serializable> emitter)
        Description copied from interface: MapReduce
        The map() method is logically executed at all vertices in the graph in parallel. The map() method emits key/value pairs given some analysis of the data in the vertices (and/or its incident edges). All MapReduce classes must at least provide an implementation of MapReduce#map(Vertex, MapEmitter).
        Parameters:
        vertex - the current vertex being map() processed.
        emitter - the component that allows for key/value pairs to be emitted to the next stage.

      • reduce

        public void reduce​(MapReduce.NullObject key,
                   Iterator<Serializable> values,
                   MapReduce.ReduceEmitter<MapReduce.NullObject,​Integer> emitter)
        Description copied from interface: MapReduce
        The reduce() method is logically on the "machine" the respective key hashes to. The reduce() method combines all the values associated with the key and emits key/value pairs.
        Parameters:
        key - the key that has aggregated values
        values - the aggregated values associated with the key
        emitter - the component that allows for key/value pairs to be emitted as the final result.

      • generateFinalResult

        public Integer generateFinalResult​(Iterator<KeyValue<MapReduce.NullObject,​Integer>> keyValues)
        Description copied from interface: MapReduce
        The key/value pairs emitted by reduce() (or map() in a map-only job) can be iterated to generate a local JVM Java object.
        Parameters:
        keyValues - the key/value pairs that were emitted from reduce() (or map() in a map-only job)
        Returns:
        the resultant object formed from the emitted key/values.

      • getMemoryKey

        public String getMemoryKey()
        Description copied from interface: MapReduce
        The results of the MapReduce job are associated with a memory-key to ultimately be stored in Memory.
        Returns:
        the memory key of the generated result object.