Stores the resolved UriConstraints in the cache together with the $routeValues

@param ResolveContext $resolveContext
@param UriConstraints $uriConstraints
@param RouteTags|null $resolvedTags
@return void
482157
public function storeResolvedUriConstraints(ResolveContext $resolveContext, UriConstraints $uriConstraints, RouteTags $resolvedTags = null)
    {
        $routeValues = $this->convertObjectsToHashes($resolveContext->getRouteValues());
        if ($routeValues === null) {
            return;
        }

        $cacheIdentifier = $this->buildResolveCacheIdentifier($resolveContext, $routeValues);
        $tags = $this->generateRouteTags($uriConstraints->getPathConstraint(), $routeValues);
        if ($resolvedTags !== null) {
            $tags = array_unique(array_merge($resolvedTags->getTags(), $tags));
        }
        $this->resolveCache->set($cacheIdentifier, $uriConstraints, $tags);
    }
259650
public static URIResolver createSAXURIResolver(Resolver resolver) {
    final SAXResolver saxResolver = new SAXResolver(resolver);
    return new URIResolver() {
      public Source resolve(String href, String base) throws TransformerException {
        try {
          return saxResolver.resolve(href, base);
        }
        catch (SAXException e) {
          throw toTransformerException(e);
        }
        catch (IOException e) {
          throw new TransformerException(e);
        }
      }
    };
  }
1097885
public void setResolvers(java.util.Collection<Resolver> resolvers) {
        if (resolvers == null) {
            this.resolvers = null;
            return;
        }

        this.resolvers = new java.util.ArrayList<Resolver>(resolvers);
    }
129365
public function merge(UriConstraints $uriConstraints): self
    {
        $mergedConstraints = array_merge($this->constraints, $uriConstraints->constraints);
        return new static($mergedConstraints);
    }
653510
private void registerActionRepositories(FeatureContext context, CrnkBoot boot) {
        ResourceRegistry resourceRegistry = boot.getResourceRegistry();
        Collection<RegistryEntry> registryEntries = resourceRegistry.getEntries();
        for (RegistryEntry registryEntry : registryEntries) {
            ResourceRepositoryInformation repositoryInformation = registryEntry.getRepositoryInformation();
            if (repositoryInformation != null && !repositoryInformation.getActions().isEmpty()) {
                ResourceRepositoryAdapter repositoryAdapter = registryEntry.getResourceRepository();
                Object resourceRepository = repositoryAdapter.getResourceRepository();
                context.register(resourceRepository);
            }
        }
    }
174774
public function execute($actionContext) {
        $this->url = UrlHelper::action($actionContext, $this->actionName, $this->controllerName, $this->routeValues, $this->fragment);
        parent::execute($actionContext);
    }
516963
@Override
	public void cacheResult(
		List<CommerceTaxFixedRateAddressRel> commerceTaxFixedRateAddressRels) {
		for (CommerceTaxFixedRateAddressRel commerceTaxFixedRateAddressRel : commerceTaxFixedRateAddressRels) {
			if (entityCache.getResult(
						CommerceTaxFixedRateAddressRelModelImpl.ENTITY_CACHE_ENABLED,
						CommerceTaxFixedRateAddressRelImpl.class,
						commerceTaxFixedRateAddressRel.getPrimaryKey()) == null) {
				cacheResult(commerceTaxFixedRateAddressRel);
			}
			else {
				commerceTaxFixedRateAddressRel.resetOriginalValues();
			}
		}
	}
1207521
public ResourceAddress resolve(StatementContext context, List<String> wildcards) {
        Resolution<ModelNode> resolution = new Resolution<ModelNode>() {
             private ModelNode modelNode;

             @Override
             public void init() {
                 this.modelNode = new ModelNode();
             }

             @Override
             public void addKeyValue(String key, String value) {
                 this.modelNode.add(key, value);
             }

             @Override
             public ModelNode getResult() {
                 return modelNode;
             }
         };

         _resolve(context, wildcards, resolution);

         return new ResourceAddress(resolution.getResult());
    }
575025
protected void specifyContentType(RouteContext routeContext) {
        if (!declaredProduces.isEmpty()) {
            // Specify first Produces content-type
            String defaultContentType = declaredProduces.get(0);
            routeContext.getResponse().contentType(defaultContentType);

            if (declaredProduces.size() > 1) {
                // negotiate content-type from Request Accept/Content-Type
                routeContext.negotiateContentType();
            }
        }
    }
888171
public static Map<String, String> resolve(final String uri, final String uriTemplate) {
        final String[] parts = URLs.decode(uri).split("/");
        final String[] templateParts = uriTemplate.split("/");
        if (parts.length != templateParts.length) {
            return null;
        }

        final Map<String, String> ret = new HashMap<>();
        for (int i = 0; i < parts.length; i++) {
            final String part = parts[i];
            final String templatePart = templateParts[i];
            if (part.equals(templatePart)) {
                continue;
            }

            String name = StringUtils.substringBetween(templatePart, "{", "}");
            if (StringUtils.isBlank(name)) {
                return null;
            }

            final String templatePartTmp = StringUtils.replace(templatePart, "{" + name + "}", "");
            final String arg = StringUtils.replace(part, templatePartTmp, "");

            ret.put(name, arg);
        }

        return ret;
    }
25943
private void loadActivitiesLocked() {
        mActivites.clear();
        if (mIntent != null) {
            List<ResolveInfo> resolveInfos =
                mContext.getPackageManager().queryIntentActivities(mIntent, 0);
            final int resolveInfoCount = resolveInfos.size();
            for (int i = 0; i < resolveInfoCount; i++) {
                ResolveInfo resolveInfo = resolveInfos.get(i);
                mActivites.add(new ActivityResolveInfo(resolveInfo));
            }
            sortActivities();
        } else {
            notifyChanged();
        }
    }
455743
@Override
    public STRATEGYSTAGETYPE resolve(final Collection<String> canonicalForms) throws IllegalArgumentException,
        ResolutionException, CoordinateParseException {
        if (canonicalForms == null) {
            throw new IllegalArgumentException("canonical forms must be provided");
        }
        for (final String canonicalForm : canonicalForms) {
            final MavenDependency dep = this.resolveDependency(canonicalForm);
            this.addDependency(dep);
        }
        return this.resolve();
    }
215035
public function resolve(
        TemplatingFixture $fixture,
        FixtureBag $unresolvedFixtures,
        TemplatingFixtureBag $resolvedFixtures,
        ResolvingContext $context
    ): TemplatingFixtureBag {
        $context->checkForCircularReference($fixture->getId());

        if (false === $fixture->extendsFixtures()) {
            return $resolvedFixtures->with($fixture);
        }

        /**
         * @var FixtureBag           $extendedFixtures
         * @var TemplatingFixtureBag $resolvedFixtures
         */
        list($extendedFixtures, $resolvedFixtures) = $this->resolveExtendedFixtures(
            $fixture,
            $fixture->getExtendedFixturesReferences(),
            $unresolvedFixtures,
            $resolvedFixtures,
            $context
        );
        $fixture = $this->getExtendedFixture($fixture, $extendedFixtures);

        return $resolvedFixtures->with($fixture);
    }
403454
private Deferred<List<String>> resolveAggTags(final Set<byte[]> tagks) {
    if (aggregated_tags != null) {
      return Deferred.fromResult(null);
    }
    aggregated_tags = new ArrayList<String>(tagks.size());
    
    final List<Deferred<String>> names = 
        new ArrayList<Deferred<String>>(tagks.size());
    for (final byte[] tagk : tagks) {
      names.add(tsdb.tag_names.getNameAsync(tagk));
    }
    
    /** Adds the names to the aggregated_tags list */
    final class ResolveCB implements Callback<List<String>, ArrayList<String>> {
      @Override
      public List<String> call(final ArrayList<String> names) throws Exception {
        for (final String name : names) {
          aggregated_tags.add(name);
        }
        return aggregated_tags;
      }
    }
    
    return Deferred.group(names).addCallback(new ResolveCB());
  }
1170147
function resolveRouters(request) {
    for (var i = 0, l = routers.length; i < l; i++) {
      var callback = routers[i].resolve(request);
      if (null != callback) {
        return Promise.resolve(callback);
      }
    }
    return Promise.reject('Route not defined for "' + request.url + '"');
  }
372223
@Override
    public View resolveView(String viewId, RequestContext context) {
        View view = super.resolveView(viewId, context);
        if (view != null) {
            return view;
        }

        for (final FlowViewResolver flowViewResolver : this.flowViewResolvers) {
            try {
                final String viewIdByConvention = flowViewResolver.getViewIdByConvention(viewId);
                view = flowViewResolver.resolveView(viewIdByConvention, context);
                if (view != null) {
                    return view;
                }
            } catch (Exception e) {
                IllegalStateException ise =
                        new IllegalStateException(
                                "Exception resolving view with name '" + viewId + "'");
                ise.initCause(e);
                throw ise;
            }
        }

        return null;
    }
738387
public void resolveBundles(BundleContext bContext, List<Bundle> bundlesToResolve) {
        if (bundlesToResolve == null || bundlesToResolve.size() == 0) {
            return;
        }

        FrameworkWiring wiring = adaptSystemBundle(bContext, FrameworkWiring.class);
        if (wiring != null) {
            ResolutionReportHelper rrh = null;
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                rrh = new ResolutionReportHelper();
                rrh.startHelper(bContext);
            }
            try {
                wiring.resolveBundles(bundlesToResolve);
            } finally {
                if (rrh != null) {
                    rrh.stopHelper();
                    Tr.debug(this, tc, rrh.getResolutionReportString());
                }
            }
        }
    }