Create a SyncMapItemFetcher to execute fetch.

@param pathServiceSid The service_sid
@param pathMapSid The map_sid
@param pathKey The key
@return SyncMapItemFetcher capable of executing the fetch
554409
public static SyncMapItemFetcher fetcher(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey) {
        return new SyncMapItemFetcher(pathServiceSid, pathMapSid, pathKey);
    }
520682
public static SyncListItemCreator creator(final String pathServiceSid, 
                                              final String pathListSid, 
                                              final Map<String, Object> data) {
        return new SyncListItemCreator(pathServiceSid, pathListSid, data);
    }
81507
Multimap<String, Map.Entry<InetAddress, Collection<Range<Token>>>> toFetch()
    {
        return toFetch;
    }
357471
public Response<List<byte[]>> hmget(final byte[] key, final byte[]... fields) {
		return new PipelineOperation<List<byte[]>>() {

			@Override
			Response<List<byte[]>> execute(Pipeline jedisPipeline) throws DynoException {
				long startTime = System.nanoTime() / 1000;
				try {
					return jedisPipeline.hmget(key, fields);
				} finally {
					long duration = System.nanoTime() / 1000 - startTime;
					opMonitor.recordSendLatency(OpName.HMGET.name(), duration, TimeUnit.MICROSECONDS);
				}
			}
		}.execute(key, OpName.HMGET);
	}
1142929
function setPathMap(
    pathMap, depth, root, parent, node,
    requestedPaths, optimizedPaths, requestedPath, optimizedPath,
    version, expired, lru, comparator, errorSelector) {

    var keys = getKeys(pathMap);

    if (keys && keys.length) {

        var keyIndex = 0;
        var keyCount = keys.length;
        var optimizedIndex = optimizedPath.index;

        do {
            var key = keys[keyIndex];
            var child = pathMap[key];
            var branch = isObject(child) && !child.$type;

            requestedPath.depth = depth;

            var results = setNode(
                root, parent, node, key, child,
                branch, false, requestedPath, optimizedPath,
                version, expired, lru, comparator, errorSelector
            );

            requestedPath[depth] = key;
            requestedPath.index = depth;

            optimizedPath[optimizedPath.index++] = key;
            var nextNode = results[0];
            var nextParent = results[1];
            if (nextNode) {
                if (branch) {
                    setPathMap(
                        child, depth + 1,
                        root, nextParent, nextNode,
                        requestedPaths, optimizedPaths, requestedPath, optimizedPath,
                        version, expired, lru, comparator, errorSelector
                    );
                } else {
                    requestedPaths.push(requestedPath.slice(0, requestedPath.index + 1));
                    optimizedPaths.push(optimizedPath.slice(0, optimizedPath.index));
                }
            }
            if (++keyIndex >= keyCount) {
                break;
            }
            optimizedPath.index = optimizedIndex;
        } while (true);
    }
}
351586
public static <A, B> Map<A, B> dotGetMapUnsafe(final Map map, final String pathString) {
        return dotGetUnsafe(map, Map.class, pathString);
    }
285578
public static Optional<Object> dotGet(final Map map, final String pathString) {
        return dotGet(map, Object.class, pathString);
    }
99125
public static SyncMapItemDeleter deleter(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey) {
        return new SyncMapItemDeleter(pathServiceSid, pathMapSid, pathKey);
    }
722408
def get(self, key):
        
        return SyncMapItemContext(
            self._version,
            service_sid=self._solution['service_sid'],
            map_sid=self._solution['map_sid'],
            key=key,
        )
512359
@Override
    public CompletableFuture<Collection<V>> getCollectionAndRefreshAsync(String key, int expireSeconds) {
        return (CompletableFuture) refreshAsync(key, expireSeconds).thenCompose(v -> getCollectionAsync(key));
    }
1369827
@Override
  public ResultStream<T> createMapSelf(ResultStream<? super T> result)
  {
    return new ResultStreamServicePrefetch<>(result, _prefetch);
  }
945750
public static FactorFetcher fetcher(final String pathServiceSid, 
                                        final String pathIdentity, 
                                        final String pathSid) {
        return new FactorFetcher(pathServiceSid, pathIdentity, pathSid);
    }
1293858
private Value generatePayload(Key key) {
        Stopwatch tracer = null;
        try {
            String payload;
            switch (key.getEntityType()) {
                case Application:
                    boolean isRemoteRegionRequested = key.hasRegions();

                    if (ALL_APPS.equals(key.getName())) {
                        if (isRemoteRegionRequested) {
                            tracer = serializeAllAppsWithRemoteRegionTimer.start();
                            payload = getPayLoad(key, registry.getApplicationsFromMultipleRegions(key.getRegions()));
                        } else {
                            tracer = serializeAllAppsTimer.start();
                            payload = getPayLoad(key, registry.getApplications());
                        }
                    } else if (ALL_APPS_DELTA.equals(key.getName())) {
                        if (isRemoteRegionRequested) {
                            tracer = serializeDeltaAppsWithRemoteRegionTimer.start();
                            versionDeltaWithRegions.incrementAndGet();
                            versionDeltaWithRegionsLegacy.incrementAndGet();
                            payload = getPayLoad(key,
                                    registry.getApplicationDeltasFromMultipleRegions(key.getRegions()));
                        } else {
                            tracer = serializeDeltaAppsTimer.start();
                            versionDelta.incrementAndGet();
                            versionDeltaLegacy.incrementAndGet();
                            payload = getPayLoad(key, registry.getApplicationDeltas());
                        }
                    } else {
                        tracer = serializeOneApptimer.start();
                        payload = getPayLoad(key, registry.getApplication(key.getName()));
                    }
                    break;
                case VIP:
                case SVIP:
                    tracer = serializeViptimer.start();
                    payload = getPayLoad(key, getApplicationsForVip(key, registry));
                    break;
                default:
                    logger.error("Unidentified entity type: {} found in the cache key.", key.getEntityType());
                    payload = "";
                    break;
            }
            return new Value(payload);
        } finally {
            if (tracer != null) {
                tracer.stop();
            }
        }
    }
1018249
private Map<String, T> sync() throws KeeperException {
    log.debug("syncing: {}", path);

    final Map<String, T> newSnapshot = Maps.newHashMap();

    // Fetch new snapshot and register watchers
    try {
      final List<String> children = getChildren();
      log.debug("children: {}", children);
      for (final String child : children) {
        final String node = ZKPaths.makePath(path, child);
        final byte[] bytes = curator.getData()
            .usingWatcher(dataWatcher)
            .forPath(node);
        final String json = new String(bytes, UTF_8);
        log.debug("child: {}={}", node, json);
        final T value;
        try {
          value = Json.read(bytes, valueType);
        } catch (IOException e) {
          log.warn("failed to parse node: {}: {}", node, json, e);
          // Treat parse failure as absence
          continue;
        }
        newSnapshot.put(node, value);
      }
    } catch (KeeperException e) {
      throw e;
    } catch (Exception e) {
      Throwables.throwIfUnchecked(e);
      throw new RuntimeException(e);
    }

    return newSnapshot;
  }
812475
public static VerificationCreator creator(final String pathServiceSid, 
                                              final String to, 
                                              final String channel) {
        return new VerificationCreator(pathServiceSid, to, channel);
    }
1312109
public static VariableCreator creator(final String pathServiceSid, 
                                          final String pathEnvironmentSid, 
                                          final String key, 
                                          final String value) {
        return new VariableCreator(pathServiceSid, pathEnvironmentSid, key, value);
    }
858789
public static Set<String> getKeysIn(final Map map, final Object... path) {
        return getMap(map, path)
            .map(m -> m
                .keySet()
                .stream()
                .map(Object::toString)
                .collect(Collectors.toSet())
            ).orElse(new HashSet<>());
    }