Create a SyncMapItemUpdater to execute update.

@param pathServiceSid The service_sid
@param pathMapSid The map_sid
@param pathKey The key
@param data The data
@return SyncMapItemUpdater capable of executing the update
173214
public static SyncMapItemUpdater updater(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey, 
                                             final Map<String, Object> data) {
        return new SyncMapItemUpdater(pathServiceSid, pathMapSid, pathKey, data);
    }
404175
public ServerBuilder service(PathMapping pathMapping, Service<HttpRequest, HttpResponse> service) {
        defaultVirtualHostBuilderUpdated();
        defaultVirtualHostBuilder.service(pathMapping, service);
        return this;
    }
148720
public FutureData<PushSubscription> update(String id, PushConnector connector, String name) {
        if (id == null || id.isEmpty() || connector == null) {
            throw new IllegalArgumentException("A push subscription ID and output parameters is required");
        }
        FutureData<PushSubscription> future = new FutureData<>();
        URI uri = newParams().forURL(config.newAPIEndpointURI(UPDATE));
        POST request = config.http()
                .POST(uri, new PageReader(newRequestCallback(future, new PushSubscription(), config)))
                .form("id", id);
        for (Map.Entry<String, String> e : connector.parameters().verifyAndGet().entrySet()) {
            request.form(e.getKey(), e.getValue());
        }
        if (name != null && !name.isEmpty()) {
            request.form("name", name);
        }
        performRequest(future, request);
        return future;
    }
1336473
public static ExecutionStepFetcher fetcher(final String pathFlowSid, 
                                               final String pathExecutionSid, 
                                               final String pathSid) {
        return new ExecutionStepFetcher(pathFlowSid, pathExecutionSid, pathSid);
    }
143154
public int onExecuteUpdate(String query, Map<Parameter, Object> parameterMap, int firstResult, int maxResult)
    {
        s = getStatelessSession();

        Query q = s.createQuery(query);
        
        q.setFirstResult(firstResult);
        q.setMaxResults(maxResult);
        
        setParameters(parameterMap, q);

        Transaction tx = onBegin();

        int i = q.executeUpdate();

        onCommit(tx);
        // tx.commit();

        return i;
    }
825644
@Override
    public void sync( NativeObject jsRWB, Object data ) {
        synchronizationPoint(jsRWB, null, data);
    }
480416
public static ExecutionStepContextFetcher fetcher(final String pathFlowSid, 
                                                      final String pathExecutionSid, 
                                                      final String pathStepSid) {
        return new ExecutionStepContextFetcher(pathFlowSid, pathExecutionSid, pathStepSid);
    }
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);
    }
}
925368
public static WorkerChannelUpdater updater(final String pathWorkspaceSid, 
                                               final String pathWorkerSid, 
                                               final String pathSid) {
        return new WorkerChannelUpdater(pathWorkspaceSid, pathWorkerSid, pathSid);
    }
359499
public ActionFuture<UpdateResponse>
    upsertDataASyncWithObjectMapper(Object sourceObject, String index,
            String type, String id) {
        return upsertDataAsync(
                JMElasticsearchUtil.buildSourceByJsonMapper(sourceObject),
                index, type, id);
    }
512411
public UpdateResponse upsertData(Map<String, ?> source, String index,
            String type, String id) {
        return upsertQuery(buildPrepareUpsert(index, type, id, source));
    }
554409
public static SyncMapItemFetcher fetcher(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey) {
        return new SyncMapItemFetcher(pathServiceSid, pathMapSid, pathKey);
    }
58932
def sync_map_items(self):
        
        if self._sync_map_items is None:
            self._sync_map_items = SyncMapItemList(
                self._version,
                service_sid=self._solution['service_sid'],
                map_sid=self._solution['sid'],
            )
        return self._sync_map_items
311269
public static MessageDeleter deleter(final String pathServiceSid, 
                                         final String pathChannelSid, 
                                         final String pathSid) {
        return new MessageDeleter(pathServiceSid, pathChannelSid, pathSid);
    }
844515
public static SyncListItemDeleter deleter(final String pathServiceSid, 
                                              final String pathListSid, 
                                              final Integer pathIndex) {
        return new SyncListItemDeleter(pathServiceSid, pathListSid, pathIndex);
    }
733937
public static StepContextFetcher fetcher(final String pathFlowSid, 
                                             final String pathEngagementSid, 
                                             final String pathStepSid) {
        return new StepContextFetcher(pathFlowSid, pathEngagementSid, pathStepSid);
    }
1081426
private Map<String, Object> getMap(String[] pathKeys)
    {
        if (pathKeys == null)
        {
            return (Map<String, Object>)resourceData;
        }
        
        Map<String, Object> selected = (Map<String, Object>)resourceData;
    
        for(int i = 0; i < pathKeys.length; i++)
        {
            if (selected.containsKey(pathKeys[i]) && selected.get(pathKeys[i]).getClass().equals(resourceData.getClass()))
            {
                selected = (Map<String, Object>) selected.get(pathKeys[i]);
            }
            else
            {
                return null;
            }
        }
        
        return selected;
    }