Create a SyncListItemUpdater to execute update.

@param pathServiceSid The service_sid
@param pathListSid The list_sid
@param pathIndex The index
@param data The data
@return SyncListItemUpdater capable of executing the update
554305
public static SyncListItemUpdater updater(final String pathServiceSid, 
                                              final String pathListSid, 
                                              final Integer pathIndex, 
                                              final Map<String, Object> data) {
        return new SyncListItemUpdater(pathServiceSid, pathListSid, pathIndex, data);
    }
801001
private static Path pathForMetadata(Path root, String namespace, String name) {
    return new Path(
        FileSystemDatasetRepository.pathForDataset(root, namespace, name),
        METADATA_DIRECTORY);
  }
374785
public static PathMetadata forArrayAccess(Path<?> parent, Expression<Integer> index) {
        return new PathMetadata(parent, index, PathType.ARRAYVALUE);
    }
549968
public static <R> List<R> applyPathListAndGetResultList(List<Path> pathList,
			Function<Path, R> function) {
		return pathList.parallelStream().map(function).collect(toList());
	}
892793
public ActionFuture<IndexResponse> sendDataAsyncWithObjectMapper(
            Object sourceObject, String index, String type, String id) {
        return indexQueryAsync(buildIndexRequest(
                JMElasticsearchUtil.buildSourceByJsonMapper(sourceObject),
                index, type, id));
    }
292025
public static PathMetadata forListAccess(Path<?> parent, @Nonnegative int index) {
        return new PathMetadata(parent, index, PathType.LISTVALUE_CONSTANT);
    }
1234287
public static FunctionVersionFetcher fetcher(final String pathServiceSid, 
                                                 final String pathFunctionSid, 
                                                 final String pathSid) {
        return new FunctionVersionFetcher(pathServiceSid, pathFunctionSid, pathSid);
    }
1214204
@Override
    public void executeListMultiActions() throws CmsRuntimeException {

        if (getParamListAction().equals(LIST_MACTION_DELETE)) {
            // execute the delete multiaction
            List<String> removedItems = new ArrayList<String>();
            Iterator<CmsListItem> itItems = getSelectedItems().iterator();
            while (itItems.hasNext()) {
                CmsListItem listItem = itItems.next();
                try {
                    OpenCms.getScheduleManager().unscheduleJob(getCms(), listItem.getId());
                    removedItems.add(listItem.getId());
                } catch (CmsException e) {
                    throw new CmsRuntimeException(
                        Messages.get().container(Messages.ERR_UNSCHEDULE_JOB_1, listItem.getId()),
                        e);
                }
            }
            // update the XML configuration
            writeConfiguration(false);
        } else if (getParamListAction().equals(LIST_MACTION_ACTIVATE)
            || getParamListAction().equals(LIST_MACTION_DEACTIVATE)) {
            // execute the activate or deactivate multiaction
            Iterator<CmsListItem> itItems = getSelectedItems().iterator();
            boolean activate = getParamListAction().equals(LIST_MACTION_ACTIVATE);
            while (itItems.hasNext()) {
                // toggle the active state of the selected item(s)
                CmsListItem listItem = itItems.next();
                try {
                    CmsScheduledJobInfo job = (CmsScheduledJobInfo)OpenCms.getScheduleManager().getJob(
                        listItem.getId()).clone();
                    job.setActive(activate);
                    OpenCms.getScheduleManager().scheduleJob(getCms(), job);
                } catch (CmsException e) {
                    throw new CmsRuntimeException(
                        Messages.get().container(Messages.ERR_SCHEDULE_JOB_1, listItem.getId()),
                        e);
                }
            }
            // update the XML configuration
            writeConfiguration(true);
        } else {
            throwListUnsupportedActionException();
        }
        listSave();
    }
360964
public ActionFuture<IndexResponse> sendDataAsync(
            Map<String, ?> source, String index, String type, String id) {
        return indexQueryAsync(buildIndexRequest(source, index, type, id));
    }
99125
public static SyncMapItemDeleter deleter(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey) {
        return new SyncMapItemDeleter(pathServiceSid, pathMapSid, pathKey);
    }
695677
public OperationFuture<LoadBalancerPool> update(
            LoadBalancerPool loadBalancerPool,
            List<LoadBalancerNodeMetadata> nodesList
    ) {
        LoadBalancerPoolMetadata loadBalancerPoolMetadata = loadBalancerPoolService.findByRef(
                loadBalancerPool
        );

        loadBalancerNodeClient.update(
                loadBalancerPoolMetadata.getDataCenterId(),
                loadBalancerPoolMetadata.getLoadBalancerId(),
                loadBalancerPoolMetadata.getId(),
                nodesList
        );

        return new OperationFuture<>(
                loadBalancerPool,
                new NoWaitingJobFuture()
        );
    }
900505
public void syncPersistNewDirectory(MutableInodeDirectory dir)
      throws InvalidPathException, FileDoesNotExistException, IOException {
    dir.setPersistenceState(PersistenceState.TO_BE_PERSISTED);
    syncPersistDirectory(dir).ifPresent(status -> {
      // If the directory already exists in the UFS, update our metadata to match the UFS.
      dir.setOwner(status.getOwner())
          .setGroup(status.getGroup())
          .setMode(status.getMode());

      Long lastModificationTime = status.getLastModifiedTime();
      if (lastModificationTime != null) {
        dir.setLastModificationTimeMs(lastModificationTime, true);
      }
    });
    dir.setPersistenceState(PersistenceState.PERSISTED);
  }
509646
public static FactorUpdater updater(final String pathServiceSid, 
                                        final String pathIdentity, 
                                        final String pathSid) {
        return new FactorUpdater(pathServiceSid, pathIdentity, pathSid);
    }
1246060
public static StreamMessageCreator creator(final String pathServiceSid, 
                                               final String pathStreamSid, 
                                               final Map<String, Object> data) {
        return new StreamMessageCreator(pathServiceSid, pathStreamSid, data);
    }
791607
def create(self, data):
        
        data = values.of({'Data': serialize.object(data), })

        payload = self._version.create(
            'POST',
            self._uri,
            data=data,
        )

        return SyncListItemInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            list_sid=self._solution['list_sid'],
        )
637057
public Collection<DavChild> syncReport(final BasicHttpClient cl,
                                         final String path,
                                         final String syncToken,
                                         final Collection<QName> props) throws Throwable {
    final StringWriter sw = new StringWriter();
    final XmlEmit xml = getXml();

    addNs(xml, WebdavTags.namespace);

    xml.startEmit(sw);

    /*
      <?xml version="1.0" encoding="utf-8" ?>
      <D:sync-collection xmlns:D="DAV:"
                         xmlns:C="urn:ietf:params:xml:ns:caldav">
        <D:sync-token/>
        <D:prop>
          <D:getetag/>
        </D:prop>
      </D:sync-collection>
     */
    xml.openTag(WebdavTags.syncCollection);
    if (syncToken == null) {
      xml.emptyTag(WebdavTags.syncToken);
    } else {
      xml.property(WebdavTags.syncToken, syncToken);
    }
    xml.property(WebdavTags.synclevel, "1");
    xml.openTag(WebdavTags.prop);
    xml.emptyTag(WebdavTags.getetag);

    if (props != null) {
      for (final QName pr: props) {
        if (pr.equals(WebdavTags.getetag)) {
          continue;
        }

        addNs(xml, pr.getNamespaceURI());
        xml.emptyTag(pr);
      }
    }

    xml.closeTag(WebdavTags.prop);
    xml.closeTag(WebdavTags.syncCollection);

    final byte[] content = sw.toString().getBytes();

    final int res = sendRequest(cl, "REPORT", path,
                                depth0,
                                "text/xml", // contentType,
                                content.length, // contentLen,
                                content);

    if (res == HttpServletResponse.SC_NOT_FOUND) {
      return null;
    }

    final int SC_MULTI_STATUS = 207; // not defined for some reason
    if (res != SC_MULTI_STATUS) {
      if (debug()) {
        debug("Got response " + res + " for path " + path);
      }

      //throw new Exception("Got response " + res + " for path " + path);
      return null;
    }

    final Document doc = parseContent(cl.getResponseBodyAsStream());

    final Element root = doc.getDocumentElement();

    /*    <!ELEMENT multistatus (response+, responsedescription?) > */

    expect(root, WebdavTags.multistatus);

    return processResponses(getChildren(root), null);
  }
1224697
public static ReservationUpdater updater(final String pathWorkspaceSid, 
                                             final String pathTaskSid, 
                                             final String pathSid) {
        return new ReservationUpdater(pathWorkspaceSid, pathTaskSid, pathSid);
    }