Create a SyncListItemFetcher to execute fetch.

@param pathServiceSid The service_sid
@param pathListSid The list_sid
@param pathIndex The index
@return SyncListItemFetcher capable of executing the fetch
777769
public static SyncListItemFetcher fetcher(final String pathServiceSid, 
                                              final String pathListSid, 
                                              final Integer pathIndex) {
        return new SyncListItemFetcher(pathServiceSid, pathListSid, pathIndex);
    }
413869
private void prefetchFromDestination() throws JMSException
    {
        // Lazy test, do not synchronize here but on response (see addToPrefetchQueue())
    	if (closed)
            return;

    	if (traceEnabled)
    		log.trace("#"+id+" Prefetching more from destination "+destination);
    	
    	// Ask for more
        PrefetchQuery query = new PrefetchQuery();
        query.setSessionId(session.getId());
        query.setConsumerId(id);
        transportEndpoint.nonBlockingRequest(query);
    }
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);
  }
1091626
public static VariableFetcher fetcher(final String pathServiceSid, 
                                          final String pathEnvironmentSid, 
                                          final String pathSid) {
        return new VariableFetcher(pathServiceSid, pathEnvironmentSid, pathSid);
    }
563145
function createRouterDispatcher({
    runtimeRouters,
    reqQuery,
    reqMethod,
    reqPath,
    viewRoot,
    extension,
    syncDataMatch,
    asyncDataMatch
}) {
    if (Number(reqQuery.mode) === 1) {
        return;
    }

    let dispatcher;
    const routers = values(runtimeRouters).reduce(
        (prev, item) => prev.concat(item),
        []
    );
    routers.some(function(router) {
        const { filePath, method, sync, url, handler } = router;

        const METHODS = ['GET', 'POST', 'PUT', 'DELETE'];
        const upperMethod = method && method.toUpperCase() || '';
        const notMatchMethod = upperMethod && METHODS.includes(upperMethod) && upperMethod !== reqMethod;

        if (!reqPath.match(pathToRegexp(url)) || notMatchMethod) {
            return false;
        }

        dispatcher = {
            router,
            filePath,
            handler
        };

        if (sync) {
            const tplName = removeSuffix(filePath, extension);
            return Object.assign(dispatcher, {
                type: 'sync',
                pagePath: path.join(viewRoot, `${tplName}.${extension}`),
                dataPath: syncDataMatch(ensureJSONExtension(tplName))
            });
        }

        return Object.assign(dispatcher, {
            type: 'async',
            dataPath: asyncDataMatch(ensureJSONExtension(filePath))
        });
    });

    return dispatcher;
}
292025
public static PathMetadata forListAccess(Path<?> parent, @Nonnegative int index) {
        return new PathMetadata(parent, index, PathType.LISTVALUE_CONSTANT);
    }
945750
public static FactorFetcher fetcher(final String pathServiceSid, 
                                        final String pathIdentity, 
                                        final String pathSid) {
        return new FactorFetcher(pathServiceSid, pathIdentity, pathSid);
    }
528274
@Override
    public java.util.concurrent.Future<ListPublicKeysResult> listPublicKeysAsync(
            com.amazonaws.handlers.AsyncHandler<ListPublicKeysRequest, ListPublicKeysResult> asyncHandler) {

        return listPublicKeysAsync(new ListPublicKeysRequest(), asyncHandler);
    }
406448
@Override
    public java.util.concurrent.Future<ListTagsForResourceResult> listTagsForResourceAsync(
            com.amazonaws.handlers.AsyncHandler<ListTagsForResourceRequest, ListTagsForResourceResult> asyncHandler) {

        return listTagsForResourceAsync(new ListTagsForResourceRequest(), asyncHandler);
    }
1086314
public static MessageFetcher fetcher(final String pathServiceSid, 
                                         final String pathChannelSid, 
                                         final String pathSid) {
        return new MessageFetcher(pathServiceSid, pathChannelSid, pathSid);
    }
513660
private void createPathQuery(String path, int operation)
   {
      MergingPathQueryNode pathNode =
         new MergingPathQueryNode(operation, factory.createPathQueryNode(null).getValidJcrSystemNodeTypeNames());
      pathNode.setAbsolute(true);

      if (path.equals("/"))
      {
         pathNode.addPathStep(factory.createLocationStepQueryNode(pathNode));
         pathConstraints.add(pathNode);
         return;
      }

      String[] names = path.split("/");

      for (int i = 0; i < names.length; i++)
      {
         if (names[i].length() == 0)
         {
            if (i == 0)
            {
               // root
               pathNode.addPathStep(factory.createLocationStepQueryNode(pathNode));
            }
            else
            {
               // descendant '//' -> invalid path
               // todo throw or ignore?
               // we currently do not throw and add location step for an
               // empty name (which is basically the root node)
               pathNode.addPathStep(factory.createLocationStepQueryNode(pathNode));
            }
         }
         else
         {
            int idx = names[i].indexOf('[');
            String name;
            int index = LocationStepQueryNode.NONE;
            if (idx > -1)
            {
               // contains index
               name = names[i].substring(0, idx);
               String suffix = names[i].substring(idx);
               String indexStr = suffix.substring(1, suffix.length() - 1);
               if (indexStr.equals("%"))
               {
                  // select all same name siblings
                  index = LocationStepQueryNode.NONE;
               }
               else
               {
                  try
                  {
                     index = Integer.parseInt(indexStr);
                  }
                  catch (NumberFormatException e)
                  {
                     log.warn("Unable to parse index for path element: " + names[i]);
                  }
               }
               if (name.equals("%"))
               {
                  name = null;
               }
            }
            else
            {
               // no index specified
               // - index defaults to 1 if there is an explicit name test
               // - index defaults to NONE if name test is %
               name = names[i];
               if (name.equals("%"))
               {
                  name = null;
               }
               else
               {
                  index = 1;
               }
            }
            InternalQName qName = null;
            if (name != null)
            {
               try
               {
                  qName = resolver.parseJCRName(name).getInternalName();
               }
               catch (NamespaceException e)
               {
                  throw new IllegalArgumentException("Illegal name: " + name, e);
               }
               catch (RepositoryException e)
               {
                  throw new IllegalArgumentException("Illegal name: " + name, e);
               }

            }
            // if name test is % this means also search descendants
            boolean descendant = name == null;
            LocationStepQueryNode step = factory.createLocationStepQueryNode(pathNode);
            step.setNameTest(qName);
            step.setIncludeDescendants(descendant);
            if (index > 0)
            {
               step.setIndex(index);
            }
            pathNode.addPathStep(step);
         }
      }
      pathConstraints.add(pathNode);
   }
246625
public AsyncLookupInBuilder get(String... paths) {
        if (paths == null || paths.length == 0) {
            throw new IllegalArgumentException("Path is mandatory for subdoc get");
        }
        for (String path : paths) {
            if (StringUtil.isNullOrEmpty(path)) {
                throw new IllegalArgumentException("Path is mandatory for subdoc get");
            }
            this.specs.add(new LookupSpec(Lookup.GET, path));
        }
        return this;
    }
792628
public static Set<String> dotGetKeysIn(final Map map, final String pathString) {
        return dotGetMap(map, pathString)
                .map(m -> m
                        .keySet()
                        .stream()
                        .map(Object::toString)
                        .collect(Collectors.toSet())
                ).orElse(new HashSet<>());
    }
1264145
public final AbstractItem next(long lockID) throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "next", Long.valueOf(lockID));

        final AbstractItemLink lockedMatchingLink = _next(lockID);

        // retrieve the item from the link
        AbstractItem lockedMatchingItem = null;
        if (null != lockedMatchingLink)
        {
            lockedMatchingItem = lockedMatchingLink.getItem();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "next", lockedMatchingItem);
        return lockedMatchingItem;
    }
579405
public static AssetVersionFetcher fetcher(final String pathServiceSid, 
                                              final String pathAssetSid, 
                                              final String pathSid) {
        return new AssetVersionFetcher(pathServiceSid, pathAssetSid, pathSid);
    }
1127265
def StartFileFetch(self, pathspec, request_data=None):
    """"""
    # Create an index so we can find this pathspec later.
    self.state.indexed_pathspecs.append(pathspec)
    self.state.request_data_list.append(request_data)
    self._TryToStartNextPathspec()
487398
public static void consumePathList(boolean isParallel, List<Path> pathList,
			Consumer<Path> consumer) {
		JMStream.buildStream(isParallel, pathList).forEach(consumer);
	}