Create a resolver with the same classes as the initialized resolver.

@return RefResolver An instance of the resolver class.
353704
public function createResolver()
    {
        $resolver = $this->getResolver();
        if (isset($resolver)) {
            $resolver_class = get_class($resolver);

        // Create new retriever.
        $retriever = $resolver->getUriRetriever();
            if (isset($retriever)) {
                $retriever_class = get_class($retriever);
                $new_retriever = new $retriever_class();
            } else {
                $new_retriever = new UriRetriever();
            }

        // Store max depth before init since maxDepth is set on the parent.
        $max_depth = $resolver::$maxDepth;

        // Create new resolver.
        $new_resolver = new $resolver_class($new_retriever);

        // Sync public static properties.
        $new_resolver::$maxDepth = $max_depth;
        } else {
            $new_retriever = new UriRetriever();
            $new_resolver = new RefResolver($new_retriever);
        }

        return $new_resolver;
    }
1298111
public function createService(ServiceLocatorInterface $serviceLocator)
    {
        /** @var DoctrineObjectManagerInterface $objectManagerLocator */
        $objectManagerLocator = $serviceLocator->get(DoctrineObjectManagerInterface::class);

        return new ResolverManagerRegistryResourceListener($objectManagerLocator, $serviceLocator);
    }
763394
public function getResolver()/*# : ParameterInterface */
    {
        if (!$this->hasResolver()) {
            throw new NotFoundException(
                Message::get(Message::PARAM_RESOLVER_MISS),
                Message::PARAM_RESOLVER_MISS
            );
        }
        return $this->resolver;
    }
250673
public function newInstance()
    {
        if (!$this->instantiator instanceof InstantiatorInterface) {
            $this->instantiator = new Instantiator();
        }

        return $this->instantiator->instantiate($this->name);
    }
1317602
public function create()
    {
        $loaders = array();

        if (count($this->xmlMappings) > 1) {
            $loaders[] = new XmlFilesLoader($this->xmlMappings, $this->constraintNamespaces);
        } elseif (1 === count($this->xmlMappings)) {
            $loaders[] = new XmlFileLoader($this->xmlMappings[0], $this->constraintNamespaces);
        }

        if (count($this->yamlMappings) > 1) {
            $loaders[] = new YamlFilesLoader($this->yamlMappings, $this->constraintNamespaces);
        } elseif (1 === count($this->yamlMappings)) {
            $loaders[] = new YamlFileLoader($this->yamlMappings[0], $this->constraintNamespaces);
        }

        foreach ($this->methodMappings as $methodName) {
            $loaders[] = new StaticMethodLoader($methodName);
        }

        if ($this->annotationReader) {
            $loaders[] = new AnnotationLoader($this->annotationReader);
        }

        $loader = null;

        if (count($loaders) > 1) {
            $loader = new LoaderChain($loaders);
        } elseif (1 === count($loaders)) {
            $loader = $loaders[0];
        }

        return new LazyLoadingMetadataFactory($loader, $this->metadataCache);
    }
577304
public function prependResolver(EntryNameResolverInterface $resolver)
    {
        $priority = self::DEFAULT_PRIORITY;

        if (!$this->resolvers->isEmpty()) {
            $queue = $this->resolvers->getIterator();
            $queue->setExtractFlags(PriorityQueue::EXTR_PRIORITY);
            $extractedNode = $queue->extract();
            $priority = $extractedNode[0] + 1;
        }

        $this->resolvers->insert(
            [
                'instance' => $resolver,

            ],
            $priority
        );

        return $this;
    }
416797
function createResolver () {
    var
      resolver = {
        settled: false,
        fulfilledValues: [],
        rejectedValues: []
      },
      promise = new Promise(function promiseResolver (fulfill, reject) {
        resolver.fulfill = fulfill;
        resolver.reject = reject;
      });

    promise.fulfilled = 0;
    promise.rejected = 0;
    promise.pending = 0;
    resolver.promise = promise;

    return resolver;
  }
1357452
function resolveResolution (
  ref,
  resolver,
  bootedServices
) {
  const refParts = ref.split(':')
  return resolver(refParts, bootedServices)
}
197978
public function getInstantiator(): Instantiator
    {
        if (is_null($this->instantiator)) {
            $this->setInstantiator(new Instantiator(null, $this));
        }

        return $this->instantiator;
    }
206058
private function buildResolver(): OptionsResolver
    {
        $resolver = new OptionsResolver();
        $profile = $this->mapOfProfiles->get($this->currentProfile);

        call_user_func($profile, $resolver);

        return $resolver;
    }
1021067
def resolver(self):
        """"""
        if self._resolver is not None:
            return self._resolver
        if self._schema_path is not None:
            # the documentation for ref resolving
            # https://github.com/Julian/jsonschema/issues/98
            # https://python-jsonschema.readthedocs.org/en/latest/references/
            self._resolver = SchemaRefResolver(
                'file://' + self._schema_path + '/', self.schema)
        else:
            self._resolver = SchemaRefResolver.from_schema(self.schema)
        return self._resolver
381377
protected static function getResolvedClassInstance()
    {
        $classNamespace = static::getStaticClassAccessor();
        $resolvedClassInstance = self::getClass($classNamespace);
        
        if (! $resolvedClassInstance) {
            return self::resolveClassNameSpace($classNamespace);  
        }

        return $resolvedClassInstance;
    }
788741
public function getResolverHandler(): ResolverHandler
    {
        if (is_null(self::$globalResolverHandler)) {
            //this should be the only place where
            //a hard coded dependancy exists
            self::$globalResolverHandler = new ResolverHandler();
        }

        if (is_null($this->resolverHandler)) {
            $this->resolverHandler = self::$globalResolverHandler;
        }

        return $this->resolverHandler;
    }
333211
protected function resolver()
    {
        $table = Arr::get($this->config, 'table', $this->name);

        return $this->repository->table($table);
    }
976253
protected function resolver()
    {
        $model = Arr::get($this->config, 'model', $this->name);
        return $this->repository->make($model)->newInstance();
    }
561251
public static PropertyResolver createResolver(PropertyRetriever instanceRetriever,
            PropertyRetriever projectRetriever, PropertyRetriever frameworkRetriever) {
        return new RuntimePropertyResolver(instanceRetriever, projectRetriever, frameworkRetriever);
    }
29776
public function create()
    {
        $instance = self::createRefundTransaction($this);
        $this->setId($instance->getId());
        return $instance;
    }