Examples of resolve()

• anvil.script.Import.resolve()
• anvil.server.Zone.resolve()
• ch.agent.crnickl.api.UpdatableSchema.resolve()
  Resolve into a schema. Resolving an updatable schema resolves its base schema recursively, then adds, edits, and deletes attributes and series as specified in this updatable schema. Once resolved, the schema must be complete as determined by {@link Schema#isComplete()}. @return a schema @throws T2DBException
• client.net.sf.saxon.ce.tree.util.URI.resolve()
• com.alibaba.citrus.generictype.TypeInfo.resolve()
  在指定上下文中分析实际类型。

  相当于 {@link resolve(context, true)}。

• com.alibaba.citrus.service.dataresolver.data.ContextAwareResolver.resolve()
• com.android.tools.lint.detector.api.Location.Handle.resolve()
• com.asakusafw.dmdl.analyzer.DmdlAnalyzer.resolve()
  Resolves the all added definitions and returns the root semantics model. @return the analyzed semantics model @throws DmdlSemanticException If registered models has some errors
• com.asakusafw.runtime.util.cache.BatchFileCacheRepository.resolve()
  Put files into remote cache and returns a mapping original files into cached path. @param files the target file paths @return the resolved mapping original files into cached path;the cached path may be {@code null} if this cannot prepare cache for the corresponding original file @throws IOException if failed to put the file into cache @throws InterruptedException if interrupted while resolving cache file
• com.asakusafw.runtime.util.cache.ConcurrentBatchFileCacheRepository.resolve()
• com.asakusafw.runtime.util.cache.FileCacheRepository.resolve()
  Put a file into remote cache and returns the cached path. @param file the target file path @return the resolved path, or {@code null} path if this does not support the target file @throws IOException if failed to put the file into cache @throws InterruptedException if interrupted while resolving cache file
• com.asakusafw.runtime.util.cache.HadoopFileCacheRepository.resolve()
• com.asakusafw.utils.java.model.util.ImportBuilder.resolve()
  指定の型を可能であればインポートし、インポート後の型表現を返す。 @param type 対象の型 @return インポート後の型 @throws IllegalArgumentException 引数に{@code null}が含まれる場合
• com.asakusafw.yaess.core.CommandScript.resolve()
• com.asakusafw.yaess.core.HadoopScript.resolve()
• com.bbn.openmap.proj.coords.MGRSPoint.resolve()
  Create the mgrs string based on the internal UTM settings, should be called if the accuracy changes. @param digitAccuracy The number of digits to use for the northing andeasting numbers. 5 digits reflect a 1 meter accuracy, 4 - 10 meter, 3 - 100 meter, 2 - 1000 meter, 1 - 10,000 meter.
• com.buschmais.jqassistant.plugin.java.impl.store.resolver.PackageDescriptorResolver.resolve()
• com.caucho.config.inject.InjectManager.resolve()
  Returns the web beans component with a given binding list.
• com.cloudbees.sdk.maven.ResolvedDependenciesCache.resolve()
• com.codingcrayons.aspectfaces.variableResolver.TagVariableResolver.resolve()
• com.dci.intellij.dbn.language.common.psi.IdentifierPsiElement.resolve()
• com.dci.intellij.dbn.language.common.psi.LeafPsiElement.resolve()
• com.digitolio.jdbi.table.TableResolver.resolve()
• com.dyuproject.ioc.Resource.Resolver.resolve()
• com.esri.gpt.catalog.schema.indexable.IndexableContext.resolve()
  Resolves any inconsistencies associated with @param schema the schema being evaluated @param dom the metadata document @param esriTags the evaluated ESRI tags (/metadata/Esri)
• com.eviware.soapui.support.resolver.ResolveContext.PathToResolve.resolve()
• com.eviware.soapui.support.resolver.ResolveDialog.resolve()
• com.facebook.presto.jdbc.internal.jackson.databind.deser.impl.ReadableObjectId.resolve()
• com.fasterxml.classmate.MemberResolver.resolve()
  Method for constructing hierarchy object needed to fully resolve member information, including basic type flattening as well as addition of mix-in types in appropriate positions. @param mainType Resolved type that is the starting point (i.e. the leaf class)for member resolution. @param annotationConfig Configuration of annotation types; which ones to include, how to inherit @param annotationOverrides Definitions of annotation overrides to use, if any (may be null)
• com.fasterxml.classmate.TypeResolver.resolve()
  Factory method for resolving given base type using specified types as type parameters. Sample usage would be:

   ResolvedType type = TypeResolver.resolve(List.class, Integer.class); 

  which would be equivalent to

   ResolvedType type = TypeResolver.resolve(new GenericType<List<Integer>>() { }); 

  Note that you can mix different types of type parameters, whether already resolved ( {@link ResolvedType}), type-erased ( {@link java.lang.Class}) or generic type reference ( {@link GenericType}).
• com.fasterxml.jackson.databind.deser.impl.ReadableObjectId.resolve()
• com.foreach.across.core.installers.InstallerActionResolver.resolve()
  Resolve the action for an installer belonging to a particular group. Used by the InstallerSettings to allow ad hoc user decision if installer should be run or not. @param group Group the installer belongs to. @param installer Installer instance - not yet autowired. @return Action or null if it delegates the decision back to the InstallerSettings. @see com.foreach.across.core.installers.InstallerSettings
• com.github.dynamicextensionsalfresco.webscripts.resolutions.Resolution.resolve()
• com.google.dart.engine.internal.resolver.IncrementalResolver.resolve()
  Resolve the given node, reporting any errors or warnings to the given listener. @param node the root of the AST structure to be resolved @throws AnalysisException if the node could not be resolved
• com.google.gerrit.server.git.ProjectConfig.resolve()
• com.google.gwt.dev.jjs.ast.JMethod.Specialization.resolve()
• com.google.gwt.dev.js.ast.JsNameRef.resolve()
• com.hp.hpl.jena.n3.IRIResolver.resolve()
  Resolve the relative URI against the base of this IRIResolver. @param relURI @return the resolved IRI @throws JenaURIException If resulting URI would not be legal, absolute IRI
• com.intellij.openapi.paths.PathReference.resolve()
• com.intellij.plugins.haxe.lang.psi.HaxeReferenceExpression.resolve()
• com.intellij.psi.PsiClassType.resolve()
  Resolves the class reference and returns the resulting class. @return the class instance, or null if the reference resolve failed.
• com.intellij.psi.PsiJavaCodeReferenceElement.resolve()
• com.intellij.psi.PsiReference.resolve()
  Returns the element which is the target of the reference. @return the target element, or null if it was not possible to resolve the reference to a valid target.
• com.intellij.psi.impl.source.resolve.reference.impl.providers.PsiPackageReference.resolve()
• com.jetbrains.lang.dart.psi.DartPathOrLibraryReference.resolve()
• com.jetbrains.lang.dart.psi.DartReference.resolve()
• com.jetbrains.php.lang.psi.elements.MethodReference.resolve()
• com.lotus.sametime.lookup.Resolver.resolve()
• com.mobixess.jodb.core.ITransactionResolver.resolve()
  The method is called when concurrent object modification is detected in Client/Sever mode. The call to resolve object normally occurs during {@link ObjectContainer#commit()} call. The resolvecan also be forced with {@link JODBSessionContainer#forceResolve()} method.
  
  @param objectToResolve object to be resolved @param sessionContainer the container for the object to be resolved @param resolverContext reserved for future releases to provide extended information regarding server side changes @return true if resolve is successful, false otherwise @throws IOException
• com.mozilla.grouperfish.services.api.Index.resolve()
• com.munian.ivy.module.facade.IvyFacade.resolve()
• com.odiago.flumebase.exec.SymbolTable.resolve()
  @return the Symbol object associated with symName, or null if thatsymbol cannot be found.
• com.opengamma.core.security.impl.SimpleSecurityLink.resolve()
  Resolves the security for the latest version-correction using a security source. @param source the source to use to resolve, not null @return the resolved security, not null @throws DataNotFoundException if the security could not be resolved @throws RuntimeException if an error occurs while resolving
• com.opengamma.engine.ComputationTargetResolver.resolve()
  Resolves the specification to a real target.

  The specification contains a {@link UniqueId} that refers to a real target, such as a portfolio or security. The resolver converts this reference back to the original fully formed object. Thetype component of the specification may be used as a hint on how to resolve the unique identifier. The type field of the resolved target may be a sub-type of the hinted type that more accurately describes the target object. @param specification the specification to resolve, not null @param versionCorrection the version/correction time to perform any deep resolutions at, not null @return the resolved target, null if not found

• com.opengamma.integration.tool.portfolio.xml.TradePositionResolver.resolve()
  Mark the resolved as resolved and perform the calculations required. After calling this method, calls to the accessor methods are enabled and calls to {@link #addToPosition(String,String)} will be disallowed.
• com.opengamma.master.historicaltimeseries.HistoricalTimeSeriesResolver.resolve()
  Resolves a time-series from a bundle of identifiers and a data field.

  The desired series is specified by identifier bundle, typically a security, and the data field name, such as "price" or "volume". However, the underlying sources of data may contain multiple matching time-series. The resolver allows the preferred series to be chosen based on a key. The meaning of the key is resolver-specific, and it might be treated as a DSL or a configuration key. @param identifierBundle the bundle of identifiers to resolve, not null @param identifierValidityDate the date that the identifier must be valid on, null to use all identifiers @param dataSource the data source name associated with the time-series, null for any @param dataProvider the data provider name associated with the time-series, null for any @param dataField the type of data that the time-series represents, not null @param resolutionKey a key defining how the resolution is to occur, null for the default best match @return a resolution result for the best match, null if unable to find a match

• com.sk89q.skmcl.application.Version.resolve()
  Returns a concrete version that cen be updated and launched.

  For concrete versions, this method will simply return the same object. For virtual versions (such as "latest stable" or "latest beta), this method will attempt to find a concrete version to return

  @param application the application to resolve the version for @param offline true if the cached version should be returned instead @return a concrete version @throws OnlineRequiredException thrown if online mode is required @throws ResolutionException thrown on resolution error
• com.springsource.util.common.PropertyPlaceholderResolver.resolve()
• com.strobel.assembler.metadata.FieldReference.resolve()
• com.strobel.assembler.metadata.MetadataSystem.resolve()
• com.strobel.assembler.metadata.MethodReference.resolve()
• com.strobel.assembler.metadata.TypeReference.resolve()
• com.sun.corba.se.spi.resolver.Resolver.resolve()
  Look up the name using this resolver and return the CORBA object reference bound to this name, if any. Returns null if no object is bound to the name.
• com.sun.enterprise.config.serverbeans.PropertyResolver.resolve()
• com.sun.enterprise.jbi.serviceengine.util.soap.EndpointMetaData.resolve()
  Partially resolve the operation name. 1. If there is only one operation, use that as the operation name. 2. If there is more than one operation name, save the input parameter for matching with the soap message. 3. Since we want to work with any kind of binding, we need to only consider the abstract WSDL.
• com.sun.enterprise.module.Module.resolve()
  Ensure that this module is {@link ModuleState#RESOLVED resolved}.

  If the module is already resolved, this method does nothing. Otherwise, iterate over all declared ModuleDependency instances and use the associated ModuleRegistry to resolve it. After successful completion of this method, the module state is {@link ModuleState#RESOLVED}. @throws ResolveError if any of the declared dependency of this modulecannot be satisfied

• com.sun.enterprise.universal.glassfish.TokenResolver.resolve()
  Replace $[variables} in map with a matching property from the map that this instance was constructed with. Both names and values are replaced. @param map Map of Strings to be token-replaced
• com.sun.jersey.core.spi.factory.ContextResolverFactory.resolve()
• com.sun.org.apache.xml.internal.security.utils.resolver.ResourceResolver.resolve()
  @deprecated New clients should use {@link #resolve(Attr,String,boolean)}
• com.sun.star.bridge.XUnoUrlResolver.resolve()
• com.sun.tools.hat.internal.model.Snapshot.resolve()
  Called after reading complete, to initialize the structure
• com.sun.xml.internal.ws.api.wsdl.parser.MetaDataResolver.resolve()
  Gives {@link com.sun.xml.internal.ws.api.wsdl.parser.ServiceDescriptor} resolved from the given location.TODO: Does this method need to propogate errors? @param location metadata location @return {@link com.sun.xml.internal.ws.api.wsdl.parser.ServiceDescriptor} resolved from the location. It may be null in the cases when MetadataResolvercan get the metada associated with the metadata loction.
• com.sun.xml.ws.api.wsdl.parser.MetaDataResolver.resolve()
  Gives {@link com.sun.xml.ws.api.wsdl.parser.ServiceDescriptor} resolved from the given location.TODO: Does this method need to propogate errors? @param location metadata location @return {@link com.sun.xml.ws.api.wsdl.parser.ServiceDescriptor} resolved from the location. It may be null in the cases when MetadataResolvercan get the metada associated with the metadata loction.
• com.tuenti.supernanny.resolution.DepFetcher.resolve()
• com.tuenti.supernanny.resolution.Resolver.resolve()
  Resolve the set of artifacts to get for the list of initial requirements. @param initialRequirements @return Set of artifacts that meet all the given requirements @throws ResolutionException In case the requirements can't be met
• com.typesafe.config.Config.resolve()
  b.com/typesafehub/config/blob/master/HOCON.md">the spec) resolved. Substitutions are looked up using this Config as the root object, that is, a substitution ${foo.bar} will be replaced with the result of getValue("foo.bar").

  This method uses {@link ConfigResolveOptions#defaults()}, there is another variant {@link Config#resolve(ConfigResolveOptions)} which letsyou specify non-default options.

  A given {@link Config} must be resolved before using it to retrieveconfig values, but ideally should be resolved one time for your entire stack of fallbacks (see {@link Config#withFallback}). Otherwise, some substitutions that could have resolved with all fallbacks available may not resolve, which will be potentially confusing for your application's users.

  resolve() should be invoked on root config objects, rather than on a subtree (a subtree is the result of something like config.getConfig("foo")). The problem with resolve() on a subtree is that substitutions are relative to the root of the config and the subtree will have no way to get values from the root. For example, if you did config.getConfig("foo").resolve() on the below config file, it would not work:

   common-value = 10 foo { whatever = ${common-value} } 

  Many methods on {@link ConfigFactory} such as{@link ConfigFactory#load()} automatically resolve the loadedConfig on the loaded stack of config files.

  Resolving an already-resolved config is a harmless no-op, but again, it is best to resolve an entire stack of fallbacks (such as all your config files combined) rather than resolving each one individually. @return an immutable object with substitutions resolved @throws ConfigException.UnresolvedSubstitution if any substitutions refer to nonexistent paths @throws ConfigException some other config exception if there are other problems

• com.volantis.mcs.context.TranscodableUrlResolver.resolve()
  Resolves a transcodable image URL. @param transcodableUrl the URL to resolve @return the resolved URL @throws RepositoryException if there is an error resolving the URL.
• com.volantis.styling.compiler.FunctionResolver.resolve()
  Resolves the name to a {@link com.volantis.styling.expressions.StylingFunction}, or returns null if no matching function could be found. @param name The name of the function. @return The {@link com.volantis.styling.expressions.StylingFunction}, or null if no matching function could be found.
• com.volantis.synergetics.path.Path.resolve()
  Resolve the String path against this path @param path the path to resolve agains the base @return the Path object representing the resolved path.
• de.anomic.http.server.AlternativeDomainNames.resolve()
  for a given domain name, return a new address the new address may also be a combination of a standard domain name or an IP with ':' and a port number @param name: a domain name @return an alternative name
• de.lessvoid.nifty.tools.TargetElementResolver.resolve()
• dtool.dub.BundlePath.resolve()
• edu.cmu.cs.stage3.alice.core.reference.PropertyReference.resolve()
• edu.mit.csail.sdg.alloy4compiler.ast.Expr.resolve()
  Resolves this expression if ambiguous. (And if t.size()>0, it represents the set of tuples whose presence/absence is relevent to the parent expression) (Note: it's possible for t to be EMPTY, or even ambiguous!)

  On success: the return value will be well-typed and unambiguous

  On failure: the return value's "errors" list will be nonempty

  If we detect any type warnings, we will add the type warnings to the "warnings" collection. @param warnings - the list that will receive any warning we generate; can be null if we wish to ignore warnings

• eu.admire.dispel.parser.state.NamespaceManager.resolve()
  Resolves from a local name to a qualified name. @param name a local name or a fully qualified name. @return fully qualified name
• flex2.compiler.common.PathResolver.resolve()
  Resolve the current file used the registered SinglePathResolvers
• fr.eolya.utils.GeoLocalisation.resolve()
• fr.obeo.releng.targetplatform.resolved.ResolvedTargetPlatform.resolve()
• freemarker.core.TemplateClassResolver.resolve()
  Gets a {@link Class} based on the class name. @param className the full-qualified class name @param env the environment in which the template executes @param template the template where the operation that require theclass resolution resides in. This is null if the call doesn't come from a template. @throws TemplateException if the class can't be found or shouldn't beaccessed from a template for security reasons.
• gov.nasa.jpf.autodoc.types.scanner.TargetScanner.resolve()
  Read byte data from a list of archives.
• hudson.maven.MavenEmbedder.resolve()
• hudson.model.PermalinkProjectAction.Permalink.resolve()
• info.openurl.oom.Service.resolve()
  This method is responsible for pulling what (Referent), why (ServiceType), who (Requester), etc. information out of the ContextObject and using it to call any Java classes and methods needed to produce a result. Having obtained a result of some sort from the business logic, this method is then responsible for transforming it into an OpenURLResponse that acts as a proxy for HttpServletResponse. @param serviceType the current ServiceType in sequence as enumerated in the ContextObject @param contextObject the current ContextObject in sequence as enumerated in the OpenURLRequest @param openURLRequest the entire request from the client, represented according to the OpenURL Object Model @return null to have the ServiceType processing loop move on to the next ServiceType or non-null to abort theServiceType processing loop and return a result. @throws UnsupportedEncodingException @throws OpenURLException @throws SAXException @throws IOException @throws ParserConfigurationException @throws TransformerException @throws SecurityException @throws IllegalArgumentException @throws ClassNotFoundException @throws NoSuchMethodException @throws InstantiationException @throws IllegalAccessException @throws InvocationTargetException
• io.fabric8.agent.DeploymentBuilder.resolve()
• io.fabric8.api.PlaceholderResolver.resolve()
  Resolves the placeholder found inside the value, for the specific key of the pid. @param fabricService The fabric service @param pid The pid that contains the placeholder. @param key The key of the configuration value that contains the placeholder. @param value The value with the placeholder. @return The resolved value or EMPTY_STRING.
• io.vertx.core.spi.VerticleFactory.resolve()
• it.freedomotic.core.Resolver.resolve()
  Creates a resolved clone of the reaction in input. All commands in the reaction are resolved according to the context given in the contructor. @param r @return a clone of the resolver reaction
• it.geosolutions.unredd.stats.model.config.util.TokenResolver.resolve()
• java.net.URI.resolve()
  etf.org/rfc/rfc2396.txt">RFC 2396, section 5.2; that is:

  1. A new URI is constructed with this URI's scheme and the given URI's query and fragment components.

  2. If the given URI has an authority component then the new URI's authority and path are taken from the given URI.

  3. Otherwise the new URI's authority component is copied from this URI, and its path is computed as follows:

  1. If the given URI's path is absolute then the new URI's path is taken from the given URI.

  2. Otherwise the given URI's path is relative, and so the new URI's path is computed by resolving the path of the given URI against the path of this URI. This is done by concatenating all but the last segment of this URI's path, if any, with the given URI's path and then normalizing the result as if by invoking the {@link #normalize() normalize} method.

  The result of this method is absolute if, and only if, either this URI is absolute or the given URI is absolute.

  @param uri The URI to be resolved against this URI @return The resulting URI @throws NullPointerException If uri is null
• java.nio.file.Path.resolve()
  Resolve the given path against this path.

  If the {@code other} parameter is an {@link #isAbsolute() absolute}path then this method trivially returns {@code other}. If {@code other}is an empty path then this method trivially returns this path. Otherwise this method considers this path to be a directory and resolves the given path against this path. In the simplest case, the given path does not have a {@link #getRoot root} component, in which case this methodjoins the given path to this path and returns a resulting path that {@link #endsWith ends} with the given path. Where the given path hasa root component then resolution is highly implementation dependent and therefore unspecified. @param other the path to resolve against this path @return the resulting path @see #relativize

• java.time.temporal.TemporalField.resolve()
  Resolves this field to provide a simpler alternative or a date.

  This method is invoked during the resolve phase of parsing. It is designed to allow application defined fields to be simplified into more standard fields, such as those on {@code ChronoField}, or into a date.

  Applications should not normally invoke this method directly. @implSpec If an implementation represents a field that can be simplified, or combined with others, then this method must be implemented.

  The specified map contains the current state of the parse. The map is mutable and must be mutated to resolve the field and any related fields. This method will only be invoked during parsing if the map contains this field, and implementations should therefore assume this field is present.

  Resolving a field will consist of looking at the value of this field, and potentially other fields, and either updating the map with a simpler value, such as a {@code ChronoField}, or returning a complete {@code ChronoLocalDate}. If a resolve is successful, the code must remove all the fields that were resolved from the map, including this field.

  For example, the {@code IsoFields} class contains the quarter-of-yearand day-of-quarter fields. The implementation of this method in that class resolves the two fields plus the {@link ChronoField#YEAR YEAR} into acomplete {@code LocalDate}. The resolve method will remove all three fields from the map before returning the {@code LocalDate}.

  A partially complete temporal is used to allow the chronology and zone to be queried. In general, only the chronology will be needed. Querying items other than the zone or chronology is undefined and must not be relied on. The behavior of other methods such as {@code get}, {@code getLong}, {@code range} and {@code isSupported} is unpredictable and the results undefined.

  If resolution should be possible, but the data is invalid, the resolver style should be used to determine an appropriate level of leniency, which may require throwing a {@code DateTimeException} or {@code ArithmeticException}. If no resolution is possible, the resolve method must return null.

  When resolving time fields, the map will be altered and null returned. When resolving date fields, the date is normally returned from the method, with the map altered to remove the resolved fields. However, it would also be acceptable for the date fields to be resolved into other {@code ChronoField}instances that can produce a date, such as {@code EPOCH_DAY}.

  Not all {@code TemporalAccessor} implementations are accepted as return values.Implementations that call this method must accept {@code ChronoLocalDate}, {@code ChronoLocalDateTime}, {@code ChronoZonedDateTime} and {@code LocalTime}.

  The default implementation must return null. @param fieldValues the map of fields to values, which can be updated, not null @param partialTemporal the partially complete temporal to query for zone andchronology; querying for other things is undefined and not recommended, not null @param resolverStyle the requested type of resolve, not null @return the resolved temporal object; null if resolving onlychanged the map, or no resolve occurred @throws ArithmeticException if numeric overflow occurs @throws DateTimeException if resolving results in an error. This must not be thrownby querying a field on the temporal without first checking if it is supported

• javax.enterprise.inject.spi.BeanManager.resolve()
  Apply the ambiguous dependency resolution rules to a set of {@linkplain Bean beans}. @param < X> a common type of the beans @param beans a set of {@linkplain Bean beans} of the given type @returns the resolved bean, or null if no bean could be resolved, or null if null or an empty set is passed @throws AmbiguousResolutionException if the ambiguous dependency resolution rules fail @throws IllegalStateException if called during application initialization
• javax.xml.transform.URIResolver.resolve()
  Called by the processor when it encounters an xsl:include, xsl:import, or document() function. @param href An href attribute, which may be relative or absolute. @param base The base URI against which the first argument will be madeabsolute if the absolute URI is required. @return A Source object, or null if the href cannot be resolved,and the processor should try to resolve the URI itself. @throws TransformerException if an error occurs when trying toresolve the URI.
• jodd.petite.ParamManager.resolve()
  Returns an array of param keys that belongs to provided bean. Optionally resolves the value of returned parameters.
• juzu.impl.common.Name.resolve()
• juzu.impl.metamodel.AnnotationState.resolve()
  Returns the annotation member if present, otherwise the default value. @param key the member key @return the serializable value
• mage.abilities.Ability.resolve()
• mage.abilities.TriggeredAbility.resolve()
• mage.game.stack.StackObject.resolve()
• mondrian.olap.fun.Resolver.resolve()
  Given a particular set of arguments the function is applied to, returns the correct overloaded form of the function.

  The method adds an item to conversions every time it performs an implicit type-conversion. If there are several candidate functions with the same signature, the validator will choose the one which used the fewest implicit conversions.

  @param args Expressions which this function call is applied to. @param validator Validator @param conversions List of implicit conversions performed (out) @return The function definition which matches these arguments, or nullif no function definition that this resolver knows about matches.
• net.asfun.jangod.util.Variable.resolve()
• net.azib.ipscan.util.MDNSResolver.resolve()
• net.azib.ipscan.util.NetBIOSResolver.resolve()
• net.sf.saxon.CollectionURIResolver.resolve()
  Resolve a URI. @param href The relative URI of the collection. This corresponds to theargument supplied to the collection() function. If the collection() function was called with no arguments (to get the "default collection") this argument will be null. @param base The base URI that should be used. This is the base URI of thestatic context in which the call to collection() was made, typically the URI of the stylesheet or query module @param context The dynamic execution context @return an Iterator over the documents in the collection. The items returnedby this iterator must be instances either of xs:anyURI, or of node() (specifically, {@link net.sf.saxon.om.NodeInfo}.). If xs:anyURI values are returned, the corresponding document will be retrieved as if by a call to the doc() function: this means that the system first checks to see if the document is already loaded, and if not, calls the registered URIResolver to dereference the URI. This is the recommended approach to ensure that the resulting collection is stable: however, it has the consequence that the documents will by default remain in memory for the duration of the query or transformation.

  If the URI is not recognized, the method may either return an empty iterator, in which case no error is reported, or it may throw an exception, in which case the query or transformation fails. Returning null has the same effect as returning an empty iterator.

• net.sf.saxon.OutputURIResolver.resolve()
  Resolve an output URI. @param href The relative URI of the output document. This corresponds to thehref attribute of the xsl:result-document instruction. @param base The base URI that should be used. This is the base URI of theelement that contained the href attribute. It may be null if no systemID was supplied for the stylesheet. @return a Result object representing the destination for the XML document. Themethod can also return null, in which case the standard output URI resolver will be used to create a Result object.
• net.sf.saxon.query.StandardModuleURIResolver.resolve()
  Resolve a module URI and associated location hints. @param moduleURI The module namespace URI of the module to be imported; or null whenloading a non-library module. @param baseURI The base URI of the module containing the "import module" declaration;null if no base URI is known @param locations The set of URIs specified in the "at" clause of "import module",which serve as location hints for the module @return an array of StreamSource objects each identifying the contents of a module to beimported. Each StreamSource must contain a non-null absolute System ID which will be used as the base URI of the imported module, and either an InputSource or a Reader representing the text of the module. @throws XPathException (error XQST0059) if the module cannot be located
• net.sourceforge.temply.base.Resolver.resolve()
  @param ruleName @param category @return key=rule var name, value=value
• nexj.core.meta.integration.service.Service.resolve()
• nexj.core.meta.workflow.Workflow.resolve()
• nux.xom.pool.DocumentURIResolver.resolve()
  Called by the XQuery processor when it encounters a doc() function. @param href An href attribute, which may be relative or absolute. @param baseURI The (absolute) base URI in effect when the href attribute was encountered. @return A Document object, or null if the href cannot be resolved and theprocessor should try to resolve the URI itself. @throws ParsingException if an error occurs when trying to resolve the URI. @throws IOException if an error occurs when trying to resolve the URI. @throws TransformerException if an error occurs when trying to resolve the URI.
• org.apache.abdera.i18n.iri.IRI.resolve()
• org.apache.abdera.i18n.templates.Context.resolve()
  Resolve a value for the specified variable. The method can return either a String, an Array or a Collection.
• org.apache.abdera.protocol.server.auth.SubjectResolver.resolve()
• org.apache.abdera.protocol.server.impl.RegexTargetResolver.resolve()
• org.apache.abdera.protocol.server.impl.RouteManager.resolve()
• org.apache.abdera.protocol.server.provider.TargetResolver.resolve()
• org.apache.abdera.protocol.server.util.RegexTargetResolver.resolve()
• org.apache.abdera.util.iri.IRI.resolve()
• org.apache.aries.application.management.AriesApplicationManager.resolve()
  Resolve an AriesApplication against a set of constraints. Each ResolveConstraint represents a single proposed change to the content of an application. If no constraints are given, a default resolution will be performed. @param originalApp Original application @param constraints Constraints @throws ResolverException @return New AriesApplication
• org.apache.cassandra.CassandraServiceController.Failure.resolve()
• org.apache.cassandra.db.ColumnFamily.resolve()
• org.apache.cocoon.components.treeprocessor.variables.VariableResolver.resolve()
  Resolve all {...} patterns using the values given in the object model.
• org.apache.cocoon.components.variables.VariableResolver.resolve()
  Resolve all {...} patterns .
• org.apache.cocoon.environment.SourceResolver.resolve()
  Resolve the source. @param systemID This is either a system identifier(java.net.URL or a local file. @deprecated Use the resolveURI methods instead
• org.apache.cocoon.environment.URLFactorySourceResolver.resolve()
  Resolve the source. @param systemID This is either a system identifier(java.net.URL) or a local file.
• org.apache.cocoon.sitemap.expression.LanguageInterpreter.resolve()
• org.apache.commons.mail.DataSourceResolver.resolve()
  Resolves the given resource location to a DataSource. @param resourceLocation the location of the resource @return the DataSource @throws IOException the resource was not found
• org.apache.cxf.endpoint.EndpointResolverRegistry.resolve()
  Walk the list of registered EndpointResolvers, so as to retrieve a concrete EPR corresponding to the given abstract EPR, returning a cached reference if already resolved.

  This API is used by any actor that requires a concrete EPR (e.g. a transport-level Conduit), and must be called each and every time the EPR content is to be accessed (e.g. before each connection establishment attempt). @param logical the abstract EPR to resolve

• org.apache.cxf.jaxrs.ext.xml.XSISchemaLocation.resolve()
• org.apache.cxf.resource.ExtendedURIResolver.resolve()
• org.apache.directory.studio.ldapbrowser.core.model.IContinuation.resolve()
  Resolves the search continuation URL, asks the user which connection to use.
• org.apache.felix.bundlerepository.Resolver.resolve()
  Start the resolution process and return whether the constraints have been successfully met or not. The resolution can be interrupted by a call to Thread.interrupt() at any time. The result will be to stop the resolver and throw an InterruptedException. @return true if the resolution has succeeded else false @throws InterruptedResolutionException if the resolution has been interrupted
• org.apache.felix.framework.resolver.Resolver.resolve()
• org.apache.felix.framework.resolver.ResolverImpl.resolve()
• org.apache.felix.resolver.ResolverImpl.resolve()
• org.apache.felix.sigil.common.repository.IBundleResolver.resolve()
• org.apache.felix.sigil.common.runtime.BundleForm.resolve()
• org.apache.flex.compiler.definitions.references.IReference.resolve()
  Resolves the reference to its {@link IDefinition} in the given projectand scope. @param project The project in which to resolve the reference. @param scope The scope where the resolution is occurring. @param dependencyType The type of dependency to introduce if the referenceresolves outside of the compilation unit. @param canEscapeWith Whether the resolution should look past awith scope. @return The {@link IDefinition} the reference resolves to.
• org.apache.flex.compiler.definitions.references.IResolvedQualifiersReference.resolve()
  Resolves this reference to a definition in the given project. @param project The {@link ICompilerProject} in which to resolve thereference. @param referencingCompilationUnit The {@link ICompilationUnit} where theresolution occurs. @param dependencyType The type of dependency to introduce if thisresolves. @return The {@link IDefinition} the reference resolves to.
• org.apache.flex.compiler.internal.tree.as.ExpressionNodeBase.resolve()
• org.apache.flex.compiler.internal.tree.as.IdentifierNode.resolve()
• org.apache.flex.compiler.internal.tree.as.MemberAccessExpressionNode.resolve()
• org.apache.flex.compiler.tree.as.IExpressionNode.resolve()
  If this expression is statically known to refer to a definition return a reference to that definition. In many cases this will return the same definition as resolveType, but when an identifier resolves to an member variable or member function of a class, this method will return the IDefinition for the member variable or member function not the definition for the type of the member variable or the member function. @param project The {@link ICompilerProject} to use to do lookups. @return The {@link IDefinition} this expression refers to.
• org.apache.flex.compiler.tree.as.IIdentifierNode.resolve()
• org.apache.fulcrum.yaafi.framework.configuration.ComponentConfigurationPropertiesResolver.resolve()
  Resolve custom properties @param defaults the default properties @return the custom properties
• org.apache.geronimo.aries.GeronimoApplicationManager.resolve()
• org.apache.geronimo.kernel.config.ConfigurationResolver.resolve()
• org.apache.geronimo.system.serverinfo.ServerInfo.resolve()
  Resolves an abstract pathname to a File. @param filename a String containing a pathname,which will be resolved by {@link #resolvePath(String filename)}. @return a File value
• org.apache.hadoop.gateway.filter.rewrite.api.UrlRewriteEnvironment.resolve()
• org.apache.hadoop.gateway.filter.rewrite.spi.UrlRewriteFunctionProcessor.resolve()
• org.apache.hadoop.gateway.filter.rewrite.spi.UrlRewriteResolver.resolve()
• org.apache.hadoop.gateway.util.urltemplate.Params.resolve()
• org.apache.hadoop.gateway.util.urltemplate.Resolver.resolve()
• org.apache.hadoop.streaming.io.IdentifierResolver.resolve()
  Resolves a given identifier. This method has to be called before calling any of the getters.
• org.apache.harmony.pack200.bytecode.ClassConstantPool.resolve()
• org.apache.harmony.unpack200.bytecode.ClassConstantPool.resolve()
• org.apache.http.conn.DnsResolver.resolve()
• org.apache.http.conn.SchemePortResolver.resolve()
  Returns the actual port for the host based on the protocol scheme.
• org.apache.ibatis.builder.ResultMapResolver.resolve()
• org.apache.isis.runtimes.dflt.objectstores.sql.testsystem.SqlDataClassFactory.resolve()
• org.apache.ivy.Ivy.resolve()
• org.apache.ivy.core.resolve.ResolveEngine.resolve()
• org.apache.ivyde.eclipse.cpcontainer.IvyClasspathContainer.resolve()
  This method is here to available the Resolve all action to run in a single progress window. It is quiet ugly but it is a first way to do this quiet quickly. @param monitor
• org.apache.jackrabbit.spi.Path.resolve()
  Resolves the given path element against this path. If the given element is absolute (i.e. the root or an identifier element), then a path containing just that element is returned. Otherwise the returned path consists of this path followed by the given element. @param element path element @return resolved path
• org.apache.jackrabbit.vault.fs.api.RepositoryAddress.resolve()
  Returns a new repository address with the given path. @param path the path to include in the new address @return a new repository address
• org.apache.jetspeed.profiler.rules.RuleCriterionResolver.resolve()
  Resolver the value for a criterion. @param context The request context. @param criterion The criterion being evaluated. @return The value of the criterion or null if not found.Returns null to indicate to subclasses to continue processing.
• org.apache.karaf.features.Resolver.resolve()
• org.apache.karaf.features.internal.region.SubsystemResolver.resolve()
• org.apache.lenya.cms.linking.LinkResolver.resolve()
  Resolve a link. @param currentDocument The document which contains the link. @param linkUri The link URI. @return A link target. @throws MalformedURLException if the URI is invalid.
• org.apache.lenya.cms.usecase.UsecaseResolver.resolve()
  Resolves a usecase object. @param webappUrl The web application URL. @param name The name of the usecase. @return A usecase object. @throws ServiceException if the object could not be created.
• org.apache.maven.artifact.resolver.ArtifactResolver.resolve()
• org.apache.maven.artifact.resolver.DefaultArtifactResolver.resolve()
• org.apache.maven.plugin.dependency.utils.resolvers.ArtifactsResolver.resolve()
• org.apache.maven.plugin.dependency.utils.resolvers.DefaultArtifactsResolver.resolve()
• org.apache.maven.shared.io.location.Locator.resolve()
• org.apache.maven.shared.io.location.LocatorStrategy.resolve()
• org.apache.oozie.util.XConfiguration.resolve()
  Returns a new XConfiguration instance with all inline values resolved. @return a new XConfiguration instance with all inline values resolved.
• org.apache.openejb.assembler.classic.EjbResolver.resolve()
• org.apache.openjpa.jdbc.meta.FieldMapping.resolve()
• org.apache.shindig.common.uri.Uri.resolve()
  Derived from Harmony Resolves a given url relative to this url. Resolution rules are the same as for {@code java.net.URI.resolve(URI)}
• org.apache.sis.xml.ReferenceResolver.resolve()
  org">GeoAPI interface. @param uuid The {@code uuid} attributes. @return An object of the given type for the given {@code uuid} attribute, or {@code null} if none.
• org.apache.slider.core.conf.AggregateConf.resolve()
• org.apache.sling.api.resource.ResourceResolver.resolve()
  Resolves the resource from the given absPath optionally taking HttpServletRequest into account, such as the value of the Host request header. Returns a {@link NonExistingResource} if the path cannot be resolved to an existingand accessible resource.

  The difference between this method and the {@link #resolve(String)}method is, that this method may take request properties like the scheme, the host header or request parameters into account to resolve the resource. @param request The http servlet request object providing more hints athow to resolve the absPath. This parameter may be null in which case the implementation should use reasonable defaults. @param absPath The absolute path to be resolved to a resource. If thisparameter is null, it is assumed to address the root of the resource tree. If the path is relative it is assumed relative to the root, that is a slash is prepended to the path before resolving it. @return The {@link Resource} addressed by the absPath or a{@link NonExistingResource} if no such resource can be resolved. @throws org.apache.sling.api.SlingException Or a subclass thereof may bethrown if an error occurs trying to resolve the resource. @throws IllegalStateException if this resource resolver has already been{@link #close() closed}. @since 2.0.4

• org.apache.stanbol.enhancer.engines.refactor.dereferencer.Dereferencer.resolve()
  The resolve method dereferences location and returns input streams. Locations can be local to the file system or remote URIs. @param location @return {@link InputStream} if the location is resolved. Otherwise a {@link FileNotFoundException} isthrown. @throws FileNotFoundException
• org.apache.stanbol.enhancer.engines.refactor.dereferencer.DereferencerImpl.resolve()
• org.apache.synapse.securevault.PasswordManager.resolve()
• org.apache.synapse.securevault.SecretResolver.resolve()
  Resolved given password using an instance of a PasswordProvider @param encryptedPassword Encrypted password @return resolved password
• org.apache.tapestry.resolver.ComponentSpecificationResolver.resolve()
  Passed the namespace of a container (to resolve the type in) and the type to resolve, performs the processing. A "bare type" (without a library prefix) may be in the containerNamespace, or the framework namespace (a search occurs in that order). @param cycle current request cycle @param containerNamespace namespace that may containa library referenced in the type @param type the component specificationto find, either a simple name, or prefixed with a library id (defined for the container namespace) @see #getNamespace() @see #getSpecification()
• org.apache.tapestry.resolver.PageSpecificationResolver.resolve()
  Resolve the name (which may have a library id prefix) to a namespace (see {@link #getNamespace()}) and a specification (see {@link #getSpecification()}). @throws ApplicationRuntimeException if the name cannot be resolved
• org.apache.tapestry.util.LocalizedContextResourceFinder.resolve()
  Resolves the resource, returning a path representing the closest match (with respect to the provided locale). Returns null if no match.

  The provided path is split into a base path and a suffix (at the last period character). The locale will provide different suffixes to the base path and the first match is returned.

• org.apache.tapestry.util.LocalizedResourceFinder.resolve()
  Resolves the resource, returning a path representing the closest match (with respect to the provided locale). Returns null if no match.

  The provided path is split into a base path and a suffix (at the last period character). The locale will provide different suffixes to the base path and the first match is returned.

• org.apache.tools.ant.taskdefs.optional.depend.constantpool.ConstantPool.resolve()
  Resolve the entries in the constant pool. Resolution of the constant pool involves transforming indexes to other constant pool entries into the actual data for that entry.
• org.apache.tuscany.sca.assembly.xml.ComponentTypeProcessor.resolve()
• org.apache.tuscany.sca.assembly.xml.CompositeProcessor.resolve()
• org.apache.tuscany.sca.assembly.xml.MetaComponentProcessor.resolve()
• org.apache.tuscany.sca.definitions.xml.SCADefinitionsDocumentProcessor.resolve()
• org.apache.webbeans.container.BeanManagerImpl.resolve()
• org.apache.webbeans.container.InjectionResolver.resolve()
• org.apache.wicket.markup.resolver.IComponentResolver.resolve()
  Try to resolve a component. @param container The container parsing its markup @param markupStream The current markupStream @param tag The current component tag while parsing the markup @return component or {@code null} if not found
• org.apache.wicket.request.IRequestCycleProcessor.resolve()

  Resolves the request and returns the request target. Typically, the resolver uses the {@link org.apache.wicket.request.RequestParameters} object that is passed in.

  Implementors of this method should be careful not to mix this code with event handling code; method {@link #processEvents(RequestCycle)} is meant for that purpose.

  @param requestCycle the current request cycle @param requestParameters The request parameters object as decoded by this processor's {@link IRequestCodingStrategy}. @return the request target; has to be non-null!
• org.apache.xml.resolver.tools.CatalogResolver.resolve()
  JAXP URIResolver API
• org.apache.xml.security.utils.resolver.ResourceResolver.resolve()
  Method resolve @param uri @param BaseURI @throws ResourceResolverException
• org.archive.net.UURI.resolve()
• org.archive.wayback.replay.html.ReplayParseContext.resolve()
• org.aspectj.org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolve()
• org.aspectj.org.eclipse.jdt.internal.compiler.ast.Expression.resolve()
• org.aspectj.org.eclipse.jdt.internal.compiler.ast.FieldDeclaration.resolve()
• org.aspectj.weaver.Member.resolve()
• org.aspectj.weaver.ResolvedMember.resolve()
• org.aspectj.weaver.ResolvedMemberImpl.resolve()
• org.aspectj.weaver.ResolvedType.resolve()
• org.aspectj.weaver.UnresolvedType.resolve()
  Returns a resolved version of this type according to a particular world. @param world the {@link World} within which to resolve. @return a resolved type representing this type in the appropriate world.
• org.aspectj.weaver.World.resolve()
  Resolve a type that we require to be present in the world
• org.aspectj.weaver.bcel.BcelWorld.resolve()
• org.aspectj.weaver.patterns.Declare.resolve()
  Returns this declare mutated
• org.aspectj.weaver.patterns.DeclareParents.resolve()
• org.aspectj.weaver.patterns.DeclareParentsMixin.resolve()
• org.aspectj.weaver.patterns.ExactTypePattern.resolve()
• org.aspectj.weaver.patterns.Pointcut.resolve()
  Returns this pointcut mutated
• org.aspectj.weaver.patterns.TypePattern.resolve()
• org.camunda.bpm.engine.impl.persistence.entity.IncidentEntity.resolve()
• org.camunda.bpm.engine.impl.persistence.entity.TaskEntity.resolve()
• org.cipango.sipapp.SipMetaData.resolve()
  Resolve all servlet/filter/listener metadata from all sources: descriptors and annotations.
• org.clarent.ivyidea.resolve.IntellijDependencyResolver.resolve()
• org.drools.base.field.ClassFieldImpl.resolve()
• org.dru.clay.resolver.DependencyResolver.resolve()
• org.dru.clay.resolver.DependencyResolverImpl.resolve()
• org.dru.clay.respository.Repository.resolve()
• org.dspace.identifier.IdentifierService.resolve()
  This will resolve a DSpaceObject based on a provided Identifier. The Service will interrogate the providers in no particular order and return the first successful result discovered. If no resolution is successful, the method will return null if no object is found. TODO: Verify null is returned. @param context @param identifier @throws IdentifierNotFoundException @throws IdentifierNotResolvableException
• org.eclipse.dltk.core.index2.IElementResolver.resolve()
• org.eclipse.emf.common.util.URI.resolve()
  etf.org/rfc/rfc2396.txt">RFC 2396, "Resolving Relative References to Absolute Form."

  During resolution, empty segments, self references ("."), and parent references ("..") are interpreted, so that they can be removed from the path. Step 6(g) gives a choice of how to handle the case where parent references point to a path above the root: the offending segments can be preserved or discarded. This method preserves them. To have them discarded, please use the two-parameter form of {@link #resolve(URI,boolean) resolve}. @exception java.lang.IllegalArgumentException if base isnon-hierarchical or is relative.

• org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolve()
• org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration.resolve()
• org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall.resolve()
• org.eclipse.jdt.internal.compiler.ast.FieldDeclaration.resolve()
• org.eclipse.jgit.internal.storage.file.FileRepository.resolve()
• org.eclipse.jgit.lib.ObjectReader.resolve()
  Resolve an abbreviated ObjectId to its full form. This method searches for an ObjectId that begins with the abbreviation, and returns at least some matching candidates. If the returned collection is empty, no objects start with this abbreviation. The abbreviation doesn't belong to this repository, or the repository lacks the necessary objects to complete it. If the collection contains exactly one member, the abbreviation is (currently) unique within this database. There is a reasonably high probability that the returned id is what was previously abbreviated. If the collection contains 2 or more members, the abbreviation is not unique. In this case the implementation is only required to return at least 2 candidates to signal the abbreviation has conflicts. User friendly implementations should return as many candidates as reasonably possible, as the caller may be able to disambiguate further based on context. However since databases can be very large (e.g. 10 million objects) returning 625,000 candidates for the abbreviation "0" is simply unreasonable, so implementors should draw the line at around 256 matches. @param id abbreviated id to resolve to a complete identity. The abbreviation must have a length of at least 2. @return candidates that begin with the abbreviated identity. @throws IOException the object store cannot be read.
• org.eclipse.jgit.lib.Repository.resolve()
  Parse a git revision string and return an object id. Combinations of these operators are supported:

  • HEAD, MERGE_HEAD, FETCH_HEAD
  • SHA-1: a complete or abbreviated SHA-1
  • refs/...: a complete reference name
  • short-name: a short reference name under {@code refs/heads}, {@code refs/tags}, or {@code refs/remotes} namespace
  • tag-NN-gABBREV: output from describe, parsed by treating {@code ABBREV} as an abbreviated SHA-1.
  • id^: first parent of commit id, this is the same as {@code id^1}
  • id^0: ensure id is a commit
  • id^n: n-th parent of commit id
  • id~n: n-th historical ancestor of id, by first parent. {@code id~3} is equivalent to {@code id^1^1^1} or {@code id^^^}.
  • id:path: Lookup path under tree named by id
  • id^{commit}: ensure id is a commit
  • id^{tree}: ensure id is a tree
  • id^{tag}: ensure id is a tag
  • id^{blob}: ensure id is a blob

  The following operators are specified by Git conventions, but are not supported by this method:

  • ref@{n}: n-th version of ref as given by its reflog
  • ref@{time}: value of ref at the designated time

  @param revstr A git object references expression @return an ObjectId or null if revstr can't be resolved to any ObjectId @throws AmbiguousObjectException {@code revstr} contains an abbreviated ObjectId and thisrepository contains more than one object which match to the input abbreviation. @throws IncorrectObjectTypeException the id parsed does not meet the type required to finish applying the operators in the expression. @throws RevisionSyntaxException the expression is not supported by this implementation, or does not meet the standard syntax. @throws IOException on serious errors
• org.eclipse.jgit.storage.file.FileRepository.resolve()
• org.eclipse.jgit.util.FS.resolve()
  Resolve this file to its actual path name that the JRE can use.

  This method can be relatively expensive. Computing a translation may require forking an external process per path name translated. Callers should try to minimize the number of translations necessary by caching the results.

  Not all platforms and JREs require path name translation. Currently only Cygwin on Win32 require translation for Cygwin based paths. @param dir directory relative to which the path name is. @param name path name to translate. @return the translated path. new File(dir,name) if thisplatform does not require path name translation.

• org.eclipse.osgi.service.urlconversion.URLConverter.resolve()
  Converts a URL that uses a client-defined protocol into a URL that uses a protocol which is native to the Java class library (file, jar, http, etc).

  Note however that users of this API should not assume too much about the results of this method. While it may consistently return a file: URL in certain installation configurations, others may result in jar: or http: URLs.

  If the protocol is not recognized by this converter, then the original URL is returned as-is.

  @param url the original URL @return the resolved URL or the original if the protocol is unknown to this converter @exception IOException if unable to resolve URL @throws IOException if an error occurs during the resolution @since 3.2
• org.eclipse.pde.core.target.ITargetDefinition.resolve()
• org.eclipse.sapphire.java.internal.StandardJavaTypeReferenceService.resolve()
• org.eclipse.sapphire.java.jdt.internal.JdtJavaTypeReferenceService.resolve()
• org.eclipse.ui.help.AbstractHelpUI.resolve()
  Resolves the help resource href according to the help system implementation. @param href the help resource @param documentOnly if true, the resulting URL must point at the document referenced by href. Otherwise, it can be a URL that contains additional elements like navigation that the help system adds to the document. @return the fully resolved URL of the help resource or nullif not supported. Help systems that use application servers typically return URLs with http: protocol. Simple help system implementations can return URLs with file: protocol. @since 3.1
• org.eclipse.ui.help.IWorkbenchHelpSystem.resolve()
  Resolves the help resource href by converting it into a legitimate URL according to the implementation of the help system. Help resources that already have a protocol will be unchanged. @param href @param documentOnly if true, the resulting URL must pointat the document referenced by href. Otherwise, it can be a URL that contains additional elements like navigation that the help system adds to the document. @return the resolved URL or null if no help UI isavailable.
• org.eclipse.wst.common.uriresolver.internal.provisional.URIResolver.resolve()
• org.exolab.castor.builder.SGStateInfo.resolve()
• org.exolab.castor.net.URIResolver.resolve()
  Resolves the given href and documentBase. An implementation of this method should never return null. A URIException may be thrown instead. @return the URILocation for the URI. [not null]
• org.exolab.castor.xml.ClassDescriptorResolver.resolve()
  Returns the ClassDescriptor for the given class @param type the Class to find the ClassDescriptor for @return the ClassDescriptor for the given class
• org.exolab.castor.xml.util.ClassDescriptorResolverImpl.resolve()
  Returns the XMLClassDescriptor for the given class @param type the Class to find the XMLClassDescriptor for @return the XMLClassDescriptor for the given class
• org.exolab.castor.xml.util.ClassResolutionByFile.resolve()
  Tries to load a {@link ClassDescriptor} for the given type from thefilesystem by lookup the subpackage specified in {@value JDOConstants#JDO_DESCRIPTOR_PACKAGE} using the{@link ClassLoader} of the {@link ClassLoaderNature} . @param type to lookup the descriptor for. @return an instance of ClassDescriptor if found, null if not.
• org.exolab.castor.xml.util.JDOClassDescriptorResolver.resolve()
  Returns the ClassDescriptor for the given class. @param type the class name to find the ClassDescriptor for @exception ResolverException Indicates that the given {@link Class} cannot be resolved. @return the ClassDescriptor for the given class
• org.expath.pkg.repo.Package.resolve()
• org.fnlp.nlp.cn.anaphora.Anaphora.resolve()
  用了标注模型，得到指代对集合 @param str @return 指代对集合 @throws Exception
• org.geoserver.catalog.impl.CatalogImpl.resolve()
  Implementation method for resolving all {@link ResolvingProxy} instances.
• org.gradle.api.artifacts.FileCollectionDependency.resolve()
• org.gradle.api.internal.artifacts.CachingDependencyResolveContext.resolve()
• org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.DependencyGraphBuilder.resolve()
• org.gradle.api.internal.file.BaseDirConverter.resolve()
• org.gradle.api.internal.file.CompositeFileCollection.resolve()
• org.gradle.api.internal.file.CompositeFileTree.resolve()
• org.gradle.api.internal.file.FileResolver.resolve()
• org.gradle.api.internal.file.UnionFileCollection.resolve()
• org.gradle.api.internal.file.collections.DefaultConfigurableFileCollection.resolve()
• org.hibernate.hql.ast.tree.AggregateNode.resolve()
• org.hibernate.hql.ast.tree.CollectionFunction.resolve()
• org.hibernate.hql.ast.tree.DotNode.resolve()
• org.hibernate.hql.ast.tree.FromReferenceNode.resolve()
• org.hibernate.hql.ast.tree.IdentNode.resolve()
• org.hibernate.hql.ast.tree.IndexNode.resolve()
• org.hibernate.hql.ast.tree.MethodNode.resolve()
• org.hibernate.hql.ast.tree.ResolvableNode.resolve()
  Does the work of resolving an identifier or a dot
• org.hibernate.hql.internal.ast.tree.AggregateNode.resolve()
• org.hibernate.hql.internal.ast.tree.CastFunctionNode.resolve()
  Called from the hql-sql grammar after the children of the CAST have been resolved. @param inSelect Is this call part of the SELECT clause?
• org.hibernate.hql.internal.ast.tree.CollectionFunction.resolve()
• org.hibernate.hql.internal.ast.tree.DotNode.resolve()
• org.hibernate.hql.internal.ast.tree.FromReferenceNode.resolve()
• org.hibernate.hql.internal.ast.tree.IdentNode.resolve()
• org.hibernate.hql.internal.ast.tree.IndexNode.resolve()
• org.hibernate.hql.internal.ast.tree.MethodNode.resolve()
• org.hibernate.hql.internal.ast.tree.ResolvableNode.resolve()
  Does the work of resolving an identifier or a dot
• org.hibernate.type.Type.resolve()
  The second phase of 2-phase loading. Only really pertinent for entities and collections. Here we resolve the identifier to an entity or collection instance @param value an identifier or value returned by hydrate() @param owner the parent entity @param session the session @return the given value, or the value associated with the identifier @throws HibernateException An error from Hibernate @see #hydrate
• org.infernus.idea.checkstyle.model.ConfigurationLocation.resolve()
  Resolve this location to a file. @return the file to load. @throws IOException if the file cannot be loaded.
• org.itsnat.core.ItsNatVariableResolver.resolve()
  Locates and replaces any variable declaration with format ${name} contained into the specified string with the variable value converted to string (Object.toString()).

  To obtain the value the method {@link #getVariable(String)} is called,if no variable is found the variable declaration is kept as is.

  The same variable may be repeated.

  @param str the source string to resolve declared variables. @return the new string with replaced variables by values. If no variable was replaced (the original string is untouched) returns null. @see #resolve(org.w3c.dom.Node)
• org.jakstab.loader.UnresolvedSymbol.resolve()
• org.jbehave.core.io.StoryPathResolver.resolve()
• org.jbehave.core.io.UnderscoredCamelCaseResolver.resolve()
• org.jberet.job.model.PropertyResolver.resolve()
  Resolves property expressions for job-level elements contained in the job. The job's direct job properties, job parameters and system properties should already have been set up properly, e.g., when this instance was instantiated. @param job the job element whose properties need to be resolved
• org.jberet.util.PropertyResolver.resolve()
  Resolves property expressions for job-level elements contained in the job. The job's direct job properties, job parameters and system properties should already have been set up properly, e.g., when this instance was instantiated. @param job the job element whose properties need to be resolved
• org.jboss.aesh.io.Resource.resolve()
  Resolve a file that might contain (~,*,?) based on this instance and a given current working directory as argument. The argument can be null. @param cwd current working directory @return resolved files
• org.jboss.arquillian.drone.impl.DroneTestEnricher.resolve()
• org.jboss.arquillian.impl.core.ManagerImpl.resolve()
• org.jboss.arquillian.spi.TestEnricher.resolve()
  Extension point to add features to the test method arguments.
  
  IE. Argument injection
  
  The return value Object[] must match the Field[] indexes. Leave Object[] index as null if it can't be handled by this {@link TestEnricher}. @param method @return A Object[] of Arguments
• org.jboss.arquillian.test.spi.TestEnricher.resolve()
  Extension point to add features to the test method arguments.
  
  IE. Argument injection
  
  The return value Object[] must match the Field[] indexes. Leave Object[] index as null if it can't be handled by this {@link TestEnricher}. @param method @return A Object[] of Arguments
• org.jboss.as.controller.PathElement.resolve()
• org.jboss.dependency.spi.DependencyItem.resolve()
  Try to resolve @param controller the controller @return true for resolved, false otherwise
• org.jboss.dmr.ModelNode.resolve()
• org.jboss.ejb3.endpoint.deployers.EndpointResolver.resolve()
  @param unit the unit in which the EJB is known to hide @param ejbName the name of the EJB @return the bean name of the EJB container
• org.jboss.forge.addon.resource.util.ResourcePathResolver.resolve()
  Resolve the results. @return A list of resources that match the path. Empty if there are no matches.
• org.jboss.forge.shell.util.PathspecParser.resolve()
  Resolve the results. @return A list of resources that match the path. Empty if there are no matches.
• org.jboss.fresh.vfs.VFS.resolve()
  Resolves the filename up to the final target. @param ctx User's context. @param filename Filename to be resolved. @param partial If true, then last token in path is not resolved. Usefulwhen there's a need to resolve to-be-created file, etc. @return Resolved filename.
• org.jboss.mbui.gui.behaviour.StatementContext.resolve()
  Resolves a value matching the key. In a hierarchy of contexts this will match the first occurrence. @param key @return
• org.jboss.shrinkwrap.resolver.api.maven.MavenResolverSystem.resolve()
• org.jboss.shrinkwrap.resolver.api.maven.PomEquippedResolveStage.resolve()
• org.jboss.weld.manager.BeanManagerImpl.resolve()
• org.jboss.weld.resolution.TypeSafeBeanResolver.resolve()
• org.jboss.wsf.spi.management.EndpointRegistry.resolve()
  Resolve endpoints thrrough a resolve instance
• org.jboss.xb.binding.sunday.unmarshalling.DefaultSchemaResolver.resolve()
  The uses the JBossEntityResolver.resolveEntity by: 1. Using the nsUri as the systemID 2. Using the schemaLocation as the systemID 3. If that fails, the baseURI is not null, the xsd is located using URL(baseURL, schemaLocation) 4. If the baseURI is null, the xsd is located using URL(schemaLocation) @param nsUri @param localName @param baseURI @param schemaLocation @return
• org.jfree.layouting.renderer.border.RenderLength.resolve()
• org.jostraca.BasicTemplatePath.resolve()
  @see org.jostraca.TemplatePath
• org.jxchange.client.cdo121.JXCdoRecipient.Resolve()
  The Resolve method resolves a recipient's address information into a full messaging address. @param ShowDialog @return @throws JXCdoException
• org.kiji.schema.KijiURI.resolve()
  Resolve the path relative to this KijiURI. Returns a new instance. @param path The path to resolve. @return The resolved KijiURI. @throws KijiURIException If this KijiURI is malformed.
• org.lilyproject.repository.api.Link.resolve()
  A shortcut for resolve(contextRecord.getId(), idGenerator).
• org.locationtech.udig.catalog.IGeoResource.resolve()
  Blocking operation to resolve into the adaptee, if available.

  Required adaptions:

  • GeoResource.class - this
  • IGeoResourceInfo.class - getInfo( monitor ) ie about this handles contents
  • IService.class - service( monitor ) ie that is responsible for this GeoResource

  Example Use (no casting required!):

    IGeoResourceInfo info = resolve(IGeoResourceInfo.class);  

  Recommended adaptions:

  • ImageDescriptor.class (for icon provided by external service)
  • List.class - members( monitor ) ie children of this georesource as in the wms layer case

  @param adaptee @param monitor @return instance of adaptee, or null if unavailable (IGeoResourceInfo and IService must besupported) @see IGeoResourceInfo @see IService @see IResolve#resolve(Class,IProgressMonitor)
• org.locationtech.udig.catalog.IResolve.resolve()
  d not find adapter } May Block. @param adaptee @param monitor May Be Null @return Instance of type adaptee, or null if adaptee is unsuported. @throws IOException if result was unavailable due to a technical problem
• org.locationtech.udig.catalog.IResolveManager.resolve()
  Resolves an {@link IResolve} to another object or throws a {@link IllegalArgumentException} if the resolvecannot be resolved to the targetType @param resolve the {@link IResolve} to resolve. @param targetType the desired type to resolve to @param monitor A monitor for providing feedback about the current progress. @return an object of targetType.
• org.locationtech.udig.catalog.IService.resolve()
  Will attempt to morph into the adaptee, and return that object. Harded coded to capture the IService contract.

  That is we *must* resolve the following:

  • IService: this
  • IServiceInfo.class: getInfo
  • ICatalog.class: parent

  Recomended adaptations:

  • ImageDescriptor.class: for a custom icon
  • List.class: members

  May Block.

  Example implementation:

    public <T> T resolve( Class<T> adaptee, IProgressMonitor monitor ) throws IOException { if (monitor == null) monitor = new NullProgressMonitor();  if (adaptee == null) throw new NullPointerException("No adaptor specified" ); if (adaptee.isAssignableFrom(API.class)) { return adaptee.cast(getAPI(monitor)); } return super.resolve(adaptee, monitor); }  

  @param adaptee @param monitor @return instance of adaptee, or null if unavailable (IServiceInfo and List mustbe supported) @see IServiceInfo @see IGeoResource @see IResolve#resolve(Class,IProgressMonitor)
• org.locationtech.udig.catalog.memory.internal.MemoryServiceImpl.resolve()
• org.locationtech.udig.catalog.rasterings.AbstractRasterGeoResource.resolve()
• org.locationtech.udig.catalog.tests.DummyService.resolve()
• org.locationtech.udig.project.internal.impl.LayerResource.resolve()
  @see org.locationtech.udig.catalog.IGeoResource#resolve(java.lang.Class,org.eclipse.core.runtime.IProgressMonitor)
• org.meb.speedway.util.TeamResolver.resolve()
• org.mule.api.registry.TransformerResolver.resolve()
  Responsible for finding a transformer with the given criteria. Note that if a transformer is not found null should be return, an exception must NOT be thrown. @param source information about the source object including the object iself @param result information about the result object to transform to @return a transformer from the registry that matches the criteria or null if atransformer was not found @throws ResolverException Only thrown if an exception is thrown during thesearch, this exception will just be a wrapper
• org.netbeans.modules.nodejs.api.NodeJSUtils.resolve()
  Resolve a FileObject based on a name referenced by a call to, e.g., require('http') (matches a built-in library or a stub version of it) or require('./foo.js') (resolves relative to the file) or if the file is part of a NodeJS project, may resolve the main file of a library under its node_modules directory. @param name The literal name of the module (i.e. should not end with .js) @param relativeTo The file that contains the reference @return A FileObject or null
• org.objectstyle.wolips.eomodeler.core.model.EOModelGroup.resolve()
• org.objectweb.jorm.naming.api.PName.resolve()
• org.olat.core.commons.modules.bc.vfs.OlatNamedContainerImpl.resolve()
• org.olat.core.commons.modules.bc.vfs.OlatRootFolderImpl.resolve()
• org.olat.core.util.vfs.LocalFolderImpl.resolve()
  @see org.olat.core.util.vfs.VFSItem#resolveFile(java.lang.String)
• org.olat.core.util.vfs.VFSContainer.resolve()
• org.olat.core.util.vfs.VFSItem.resolve()
  a relative path. the implementation will search all its children. e.g. bla/blu/bli.txt this vfsitem's name must thus be 'bla' @param path @return
• org.omg.CosNaming.NamingContext.resolve()
• org.omg.CosNaming.NamingContextExt.resolve()
• org.onemind.commons.java.datastructure.InheritableValueMap.resolve()
• org.openntf.domino.Session.resolve()
• org.openquark.cal.compiler.ModuleNameResolver.resolve()
  Resolves the given module name and returns a ResolutionResult. @param moduleName the module name to be resolved. Can be null. @return a ResolutionResult representing the result of the resolution.
• org.opensaml.ws.message.handler.HandlerChainResolver.resolve()
  Resolve handler chain instances based on the message context. @param messageContext the message context to process @return resolved handler chains @throws HandlerException thrown if there is an error resolving the handler chain
• org.opensaml.ws.security.SecurityPolicyResolver.resolve()
• org.opentripplanner.routing.edgetype.TimetableResolver.resolve()
  Returns an updated timetable for the specified pattern if one is available in this snapshot, or the originally scheduled timetable if there are no updates in this snapshot.
• org.osgi.framework.wiring.BundleRevision.resolve()
• org.osgi.service.obr.Resolver.resolve()
  Start the resolution process and return whether the constraints have been successfully met or not. The resolution can be interrupted by a call to Thread.interrupt() at any time. The result will be to stop the resolver and throw an InterruptedException. @return true if the resolution has succeeded else false @throws InterruptedResolutionException if the resolution has been interrupted
• org.osgi.service.resolver.Resolver.resolve()
  Resolve the specified resolve context and return any new resources and wires to the caller.

  The resolver considers two groups of resources:

  • Mandatory - any resource in the {@link ResolveContext#getMandatoryResources() mandatory group} must beresolved. A failure to satisfy any mandatory requirement for these resources will result in throwing a {@link ResolutionException}
  • Optional - any resource in the {@link ResolveContext#getOptionalResources() optional group} may beresolved. A failure to satisfy a mandatory requirement for a resource in this group will not fail the overall resolution but no resources or wires will be returned for that resource.

  The resolve method returns the delta between the start state defined by {@link ResolveContext#getWirings()} and the end resolved state. That is,only new resources and wires are included.

  The behavior of the resolver is not defined if the specified resolve context supplies inconsistent information. @param context The resolve context for the resolve operation. Must not be{@code null}. @return The new resources and wires required to satisfy the specifiedresolve context. The returned map is the property of the caller and can be modified by the caller. @throws ResolutionException If the resolution cannot be satisfied.

• org.pdf4j.saxon.CollectionURIResolver.resolve()
  Resolve a URI. @param href The relative URI of the collection. This corresponds to theargument supplied to the collection() function. If the collection() function was called with no arguments (to get the "default collection") this argument will be null. @param base The base URI that should be used. This is the base URI of thestatic context in which the call to collection() was made, typically the URI of the stylesheet or query module @param context The dynamic execution context @return an Iterator over the documents in the collection. The items returnedby this iterator must be instances either of xs:anyURI, or of node() (specifically, {@link org.pdf4j.saxon.om.NodeInfo}.). If xs:anyURI values are returned, the corresponding document will be retrieved as if by a call to the doc() function: this means that the system first checks to see if the document is already loaded, and if not, calls the registered URIResolver to dereference the URI. This is the recommended approach to ensure that the resulting collection is stable: however, it has the consequence that the documents will by default remain in memory for the duration of the query or transformation.

  If the URI is not recognized, the method may either return an empty iterator, in which case no error is reported, or it may throw an exception, in which case the query or transformation fails. Returning null has the same effect as returning an empty iterator.

• org.pdf4j.saxon.OutputURIResolver.resolve()
  Resolve an output URI. @param href The relative URI of the output document. This corresponds to thehref attribute of the xsl:result-document instruction. @param base The base URI that should be used. This is the Base Output URI, typicallythe URI of the principal output document @return a Result object representing the destination for the XML document. Themethod can also return null, in which case the standard output URI resolver will be used to create a Result object.
• org.pdfclown.objects.PdfArray.resolve()
  Gets the dereferenced value corresponding to the given index.

  Remarks

  This method takes care to resolve the value returned by {@link #get(int)}.

  @param index Index of element to return. @since 0.0.8
• org.pdfclown.objects.PdfDictionary.resolve()
  Gets the dereferenced value corresponding to the given key.

  Remarks

  This method takes care to resolve the value returned by {@link #get(Object)}.

  @param key Key whose associated value is to be returned. @return null, if the map contains no mapping for this key. @since 0.0.8
• org.pentaho.reporting.engine.classic.core.layout.model.RenderLength.resolve()
• org.pentaho.reporting.engine.classic.core.style.resolver.SimpleStyleResolver.resolve()
• org.pentaho.reporting.engine.classic.core.style.resolver.StyleResolver.resolve()
• org.platformlayer.cas.CasStoreMap.resolve()
• org.python.indexer.ast.NModule.resolve()
• org.restlet.ext.rdf.internal.turtle.LexicalUnit.resolve()
  Resolves the current value as a reference or a literal or a graph of links according to the current context. @return The current value as a reference or a literal or a graph of linksaccording to the current context.
• org.rssowl.core.model.reference.AttachmentReference.resolve()
• org.rssowl.core.model.reference.FeedReference.resolve()
• org.rssowl.core.model.reference.FolderReference.resolve()
• org.rssowl.core.model.reference.NewsReference.resolve()
• org.rssowl.core.model.reference.SearchMarkReference.resolve()
• org.rssowl.core.persist.reference.AttachmentReference.resolve()
• org.rssowl.core.persist.reference.FeedLinkReference.resolve()
  Loads the Feed that this reference points to from the persistence layer and returns it. It may return null if the feed has been deleted from the persistence layer. @return the IFeed this object references. @throws PersistenceException In case an error occurs while accessing thepersistence layer.
• org.rssowl.core.persist.reference.FeedReference.resolve()
• org.rssowl.core.persist.reference.FolderReference.resolve()
• org.rssowl.core.persist.reference.NewsBinReference.resolve()
• org.rssowl.core.persist.reference.NewsReference.resolve()
• org.rssowl.core.persist.reference.SearchConditionReference.resolve()
• org.rssowl.core.persist.reference.SearchMarkReference.resolve()
• org.rssowl.ui.internal.FolderNewsMark.resolve()
  @param type the filter type to scope the resulting news properly. @param monitor a monitor to react to cancellation.
• org.semanticweb.owlapi.model.IRI.resolve()
  @param s the IRI stirng to be resolved @return s resolved against this IRI (with the URI::resolve() method,unless this IRI is opaque)
• org.sf.bee.commons.contextresolver.ContextRegExTokenizer.resolve()
• org.sonatype.sisu.bl.support.resolver.BundleResolver.resolve()
• org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver.resolve()
  Locate the {@link NamespaceHandler} for the supplied namespace URIfrom the configured mappings. @param namespaceUri the relevant namespace URI @return the located {@link NamespaceHandler}, or null if none found
• org.springframework.beans.factory.xml.NamespaceHandlerResolver.resolve()
  Resolve the namespace URI and return the located {@link NamespaceHandler}implementation. @param namespaceUri the relevant namespace URI @return the located {@link NamespaceHandler} (may be null)
• org.springframework.data.hadoop.store.strategy.naming.ChainedFileNamingStrategy.resolve()
• org.springframework.expression.BeanResolver.resolve()
  Look up the named bean and return it. @param context the current evaluation context @param beanName the name of the bean to lookup @return an object representing the bean @throws AccessException if there is an unexpected problem resolving the named bean
• org.springframework.ide.eclipse.beans.core.internal.model.namespaces.DelegatingNamespaceHandlerResolver.resolve()
• org.springframework.ide.eclipse.beans.core.internal.model.namespaces.ProjectClasspathExtensibleUriResolver.resolve()
  {@inheritDoc}
• org.springframework.test.context.ActiveProfilesResolver.resolve()
  Resolve the bean definition profiles to use when loading an {@code ApplicationContext} for the given {@linkplain Class test class}. @param testClass the test class for which the profiles should be resolved;never {@code null} @return the list of bean definition profiles to use when loading the{@code ApplicationContext}; never {@code null} @see ActiveProfiles#resolver @see ActiveProfiles#inheritProfiles
• org.springframework.xd.module.options.DefaultModuleOptionsMetadataResolver.resolve()
• org.springframework.xd.module.options.ModuleOptionsMetadataResolver.resolve()
  Return metadata about a module, as identified by the given moduleDefinition.
• org.springframework.yarn.fs.SmartResourceLocalizer.resolve()
  Manually resolve resources before distribution process is initiated. Using this method should always be optional and executed before distribution if it has not already been done.
• org.terasology.module.DependencyResolver.resolve()
• org.thechiselgroup.choosel.core.client.visualization.model.VisualItemValueResolver.resolve()
  Calculates a value for a {@link VisualItem}. @param visualItem {@link VisualItem} for which this{@link VisualItemValueResolver} is asked to calculate a value. @param context Context that allows accessing resolvers for other slots. For example, if you want to determine the color of a node's border based on it's inner color, you could use the context to find the resolver for the inner color, and darken it to resolve the border. @return Value for the {@link VisualItem}.
• org.threeten.bp.temporal.TemporalField.resolve()
  Resolves the date/time information in the builder

  This method is invoked during the resolve of the builder. Implementations should combine the associated field with others to form objects like {@code LocalDate}, {@code LocalTime} and {@code LocalDateTime} @param fieldValues the map of fields to values, which can be updated, not null @param partialTemporal the partially complete temporal to query for zone andchronology; querying for other things is undefined and not recommended, not null @param resolverStyle the requested type of resolve, not null @return the resolved temporal object; null if resolving onlychanged the map, or no resolve occurred @throws ArithmeticException if numeric overflow occurs @throws DateTimeException if resolving results in an error. This must not be thrownby querying a field on the temporal without first checking if it is supported

• org.torquebox.core.component.ComponentResolver.resolve()
• org.uberfire.java.nio.file.Path.resolve()
• org.useware.kernel.gui.behaviour.StatementContext.resolve()
  Resolves a value matching the key. In a hierarchy of contexts this will match the first occurrence. @param key @return
• org.wso2.carbon.discovery.client.DiscoveryClient.resolve()
  Send a WS-Discovery resolve request for the given service ID @param epr ID of the service to be resolved @return a TargetService object or null if the ID cannot be resolved @throws DiscoveryException if an error occured while contacting the WS-D proxy
• org.wso2.carbon.mediation.dependency.mgt.DependencyResolver.resolve()
• org.wso2.securevault.PasswordManager.resolve()
• org.wso2.securevault.SecretResolver.resolve()
  Resolved given password using an instance of a PasswordProvider @param encryptedPassword Encrypted password @return resolved password
• org.xml.sax.EntityResolver.resolve()
• protobuf.lang.psi.api.reference.PbRef.resolve()
• se.jbee.inject.Injector.resolve()
  @return Resolves the instance appropriate for the given {@link Dependency}. In case no such instance is known an exception is thrown. The null-reference will never be returned. @throws NoSuchResourceException In case no {@link Resource} in this injector's context matches the givendependency. @throws MoreFrequentExpiryException In case the resolution would cause the injection of a instance into another that has a higher {@link Expiry}. @throws DependencyCycleException In case the resolution caused a situation of cyclic dependent instances so that they cannot be injected.
• tripleplay.ui.util.BoxPoint.resolve()
  Finds the screen coordinates of the point, using the given element as the box.
• uk.co.brunella.osgi.bdt.bundle.BundleRepository.resolve()
• wyvern.tools.types.UnresolvedType.resolve()
• xtc.type.Type.resolve()
  Resolve this type. This method removes any symbolic information, i.e., wrapped types, and returns the underlying, "raw" type. @return The resolved type.

Examples of java.time.temporal.TemporalField.resolve()

Examples of javax.enterprise.inject.spi.BeanManager.resolve()

Examples of javax.xml.transform.URIResolver.resolve()

Examples of jodd.petite.ParamManager.resolve()

Examples of juzu.impl.common.Name.resolve()

Examples of juzu.impl.metamodel.AnnotationState.resolve()

Examples of mage.abilities.Ability.resolve()

Examples of mage.abilities.TriggeredAbility.resolve()

Examples of mage.game.stack.StackObject.resolve()

Examples of mondrian.olap.fun.Resolver.resolve()