How to use

readMapP

method

in

com.hazelcast.jet.core.processor.SourceProcessors

/**
 * Convenience for {@link #map(String, Predicate, Projection)}
 * which uses a {@link DistributedFunction} as the projection function.
 */
@Nonnull
public static <T, K, V> BatchSource<T> map(
    @Nonnull String mapName,
    @Nonnull Predicate<? super K, ? super V> predicate,
    @Nonnull DistributedFunction<? super Map.Entry<K, V>, ? extends T> projectionFn
) {
  return batchFromProcessor("mapSource(" + mapName + ')', readMapP(mapName, predicate, projectionFn));
}

/**
 * Returns a source that fetches entries from a local Hazelcast {@code IMap}
 * with the specified name and emits them as {@code Map.Entry}. It leverages
 * data locality by making each of the underlying processors fetch only those
 * entries that are stored on the member where it is running.
 * <p>
 * The source does not save any state to snapshot. If the job is restarted,
 * it will re-emit all entries.
 * <p>
 * If the {@code IMap} is modified while being read, or if there is a
 * cluster topology change (triggering data migration), the source may
 * miss and/or duplicate some entries.
 * <p>
 * The default local parallelism for this processor is 2 (or 1 if just 1
 * CPU is available).
 */
@Nonnull
public static <K, V> BatchSource<Entry<K, V>> map(@Nonnull String mapName) {
  return batchFromProcessor("mapSource(" + mapName + ')', readMapP(mapName));
}

    @Nonnull Projection<? super Entry<K, V>, ? extends T> projection
) {
  return batchFromProcessor("mapSource(" + mapName + ')', readMapP(mapName, predicate, projection));

  public static void main(String[] args) throws Exception {
    System.setProperty("hazelcast.logging.type", "log4j");
    Jet.newJetInstance();
    JetInstance jet = Jet.newJetInstance();
    try {

      IMapJet<Object, Object> map = jet.getMap("map");
      range(0, COUNT).parallel().forEach(i -> map.put("key-" + i, i));

      DAG dag = new DAG();

      Vertex source = dag.newVertex("map-source", SourceProcessors.readMapP(map.getName()));
      Vertex sink = dag.newVertex("file-sink", new WriteFilePSupplier(OUTPUT_FOLDER));
      dag.edge(between(source, sink));

      jet.newJob(dag).join();
      System.out.println("\nHazelcast IMap dumped to folder " + new File(OUTPUT_FOLDER).getAbsolutePath());
    } finally {
      Jet.shutdownAll();
    }
  }
}

private void rewriteDagWithSnapshotRestore(DAG dag, long snapshotId, String mapName) {
  IMap<Object, Object> snapshotMap = nodeEngine.getHazelcastInstance().getMap(mapName);
  snapshotId = SnapshotValidator.validateSnapshot(snapshotId, jobIdString(), snapshotMap);
  logger.info("State of " + jobIdString() + " will be restored from snapshot " + snapshotId + ", map=" + mapName);
  List<Vertex> originalVertices = new ArrayList<>();
  dag.iterator().forEachRemaining(originalVertices::add);
  Map<String, Integer> vertexToOrdinal = new HashMap<>();
  Vertex readSnapshotVertex = dag.newVertex(SNAPSHOT_VERTEX_PREFIX + "read",
      readMapP(mapName));
  long finalSnapshotId = snapshotId;
  Vertex explodeVertex = dag.newVertex(SNAPSHOT_VERTEX_PREFIX + "explode",
      () -> new ExplodeSnapshotP(vertexToOrdinal, finalSnapshotId));
  dag.edge(between(readSnapshotVertex, explodeVertex).isolated());
  int index = 0;
  // add the edges
  for (Vertex userVertex : originalVertices) {
    vertexToOrdinal.put(userVertex.getName(), index);
    int destOrdinal = dag.getInboundEdges(userVertex.getName()).size();
    dag.edge(new SnapshotRestoreEdge(explodeVertex, index, userVertex, destOrdinal));
    index++;
  }
}

  public static CompletableFuture<Void> copyMapUsingJob(JetInstance instance, int queueSize,
                             String sourceMap, String targetMap) {
    DAG dag = new DAG();
    Vertex source = dag.newVertex("readMap(" + sourceMap + ')', readMapP(sourceMap));
    Vertex sink = dag.newVertex("writeMap(" + targetMap + ')', writeMapP(targetMap));
    dag.edge(between(source, sink).setConfig(new EdgeConfig().setQueueSize(queueSize)));
    JobConfig jobConfig = new JobConfig()
        .setName("copy-" + sourceMap + "-to-" + targetMap);
    return instance.newJob(dag, jobConfig).getFuture();
  }
}

Vertex source = dag.newVertex("source", readMapP(DOCID_NAME));

Vertex docSource = dag.newVertex("doc-source", readMapP(DOCID_NAME));

Vertex readTickerInfoMap = dag.newVertex("readTickerInfoMap", readMapP(TICKER_INFO_MAP_NAME));
Vertex collectToMap = dag.newVertex("collectToMap",
    Processors.aggregateP(AggregateOperations.toMap(entryKey(), entryValue())));