Returns first resolver that accepts the given resolverId.
In case none is found null is returned.
@param resolverId identifier of the resolver
@return found resolver or null otherwise
510257
public static ObjectModelResolver get(String resolverId) {
        List<ObjectModelResolver> resolvers = getResolvers();

        for (ObjectModelResolver resolver : resolvers) {
            if (resolver.accept(resolverId)) {
                return resolver;
            }
        }

        return null;
    }
1067600
public ClassLoader getClassLoader() {
        return classloader != null ? classloader : (classloader = Loader.getClassLoader(ResolverUtil.class, null));
    }
439104
function Resolver(options)
	{
		if (!(this instanceof Resolver))
			return new Resolver(options);

		Logger.mixin(this, options);

		options = this.options = setProperties({}, this.options, options);

		this._cache = {};
		this._manifestCache = {};

		this._core = {};
		this._extensions = new PriorityList();
		this._manifests = new PriorityList();
		this._prefixes = new PriorityList(function(a, b)
		{
			return a.value === b.value;
		});

		this._group("Resolver Initialize", null, function()
		{
			this._initGet();
			this._initRoot();
			this._initCore();
			this._initExtension();
			this._initPrefix();
			this._initManifest();

			this._initAllowExtensionless(options.allowExtensionless);
		});
	}
1083635
@SuppressWarnings("unchecked")
    public synchronized <K, V> StoreClient<K, V> getStoreClient(String storeName,
                                                   InconsistencyResolver<Versioned<V>> resolver) {
        Pair<String, Object> key = Pair.create(storeName, (Object) resolver);
        if(!cache.containsKey(key)) {
            StoreClient<K, V> result = inner.getStoreClient(storeName, resolver);
            cache.putIfAbsent(key, result);
        }

        return (StoreClient<K, V>) cache.get(key);
    }
774124
private RelationshipResolver getResolver(Class<?> type) {
		RelationshipResolver resolver = typedResolvers.get(type);
		return resolver != null ? resolver : globalResolver;
	}
130085
public URI resolveRelative(URI uri) {
        if (uri != null && rvdOrigin != null && filterPrefix != null) {
            if (uri.isAbsolute())
                return uri;
            try {
                String uriString = uri.toString();
                if (uriString.startsWith(filterPrefix))
                    return new URI(rvdOrigin + uri.toString());
            } catch (URISyntaxException e) {
                logger.error("Cannot resolve uri: " + uri.toString() + ". Ignoring...", e);
            }
        }
        return uri;
    }
1237986
public static PropertyResolver createPrefixedResolver(final PropertyResolver resolver, String providerName, String pluginType) {
        final String projectPrefix = projectPropertyPrefix(pluginPropertyPrefix(pluginType, providerName));
        final String frameworkPrefix = frameworkPropertyPrefix(pluginPropertyPrefix(pluginType, providerName));
        return new PropertyResolver(){
            public Object resolvePropertyValue(String name, PropertyScope scope) {
                String value = null;
                if (scope.isInstanceLevel()) {
                    value = (String)resolver.resolvePropertyValue(name,scope);
                }
                if (null != value || scope == PropertyScope.InstanceOnly) {
                    return value;
                }

                if (scope.isProjectLevel()) {
                    value = (String) resolver.resolvePropertyValue(projectPrefix + name, scope);
                }
                if (null != value || scope == PropertyScope.ProjectOnly) {
                    return value;
                }

                value = (String) resolver.resolvePropertyValue(frameworkPrefix + name, scope);
                return value;
            }
        };

    }
954451
public SocketAddress resolve(RedisURI redisURI) {

        LettuceAssert.notNull(redisURI, "RedisURI must not be null");

        return resolve(redisURI, dnsResolver);
    }
1256344
@SuppressWarnings("unchecked")
    private static <V> V resolve(ProvidenceConfigContext context,
                                 Token token,
                                 Tokenizer tokenizer,
                                 PDescriptor descriptor) throws TokenizerException {
        Object value = resolveAny(context, token, tokenizer);
        if (value == null) {
            return null;
        }
        return (V) asType(descriptor, value);
    }
716625
static Object[] toArguments(List<AnnotatedValueResolver> resolvers,
                                ResolverContext resolverContext) {
        requireNonNull(resolvers, "resolvers");
        requireNonNull(resolverContext, "resolverContext");
        if (resolvers.isEmpty()) {
            return emptyArguments;
        }
        return resolvers.stream().map(resolver -> resolver.resolve(resolverContext)).toArray();
    }
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
1105457
public static ResourceResolutionComponent[] resolve(Object... resolutionParams) {
        ResourceResolutionComponent[] components = new ResourceResolutionComponent[resolutionParams.length];
        for (int i = 0; i < resolutionParams.length; i++) {
            if (resolutionParams[i] == null) {
                components[i] = new StringResolutionComponent("");
            } else if (resolutionParams[i] instanceof ResourceResolutionComponent) {
                components[i] = (ResourceResolutionComponent) resolutionParams[i];
            } else if (resolutionParams[i] instanceof Locale) {
                components[i] = new LocaleResolutionComponent((Locale) resolutionParams[i]);
            } else if (resolutionParams[i] instanceof String) {
                components[i] = new StringResolutionComponent((String) resolutionParams[i]);
            } else if (resolutionParams[i] instanceof String[]) {
                components[i] = new StringResolutionComponent((String[]) resolutionParams[i]);
            } else {
                components[i] = new StringResolutionComponent(String.valueOf(resolutionParams[i]));
            }
        }
	    return components;
    }
862992
public static Object newInstance(Class clazz, ArgumentResolver resolver){
        Validate.argumentIsNotNull(clazz);
        for (Constructor constructor : clazz.getDeclaredConstructors()) {
            if (isPrivate(constructor) || isProtected(constructor)) {
                continue;
            }

            Class [] types = constructor.getParameterTypes();
            Object[] params = new Object[types.length];
            for (int i=0; i<types.length; i++){
                try {
                    params[i] = resolver.resolve(types[i]);
                } catch (JaversException e){
                    logger.error("failed to create new instance of "+clazz.getName()+", argument resolver for arg["+i+"] " +
                                 types[i].getName() + " thrown exception: "+e.getMessage());
                    throw e;
                }
            }
            try {
                constructor.setAccessible(true);
                return constructor.newInstance(params);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        throw new JaversException(JaversExceptionCode.NO_PUBLIC_CONSTRUCTOR,clazz.getName());
    }
282355
@ObjectiveCName("pipeTo:")
    public Promise<T> pipeTo(PromiseResolver<T> resolver) {
        then(t -> resolver.result(t));
        failure(e -> resolver.error(e));
        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;
  }
117403
function Resolver(readerType) {
  // Add all fields here so that all resolvers share the same hidden class.
  this._readerType = readerType;
  this._read = null;
  this.itemsType = null;
  this.size = 0;
  this.symbols = null;
  this.valuesType = null;
}
342735
static CMARichNode resolveRichNode(Map<String, Object> rawNode) {
    final String type = (String) rawNode.get("nodeType");
    if (RESOLVER_MAP.containsKey(type)) {
      return RESOLVER_MAP.get(type).resolve(rawNode);
    } else {
      return null;
    }
  }