Resolve the requested {@link Resource}
328664
protected Resource resolveResource(String href, String base) throws TransformerException {
        final Resource resolvedResource;
        if (base != null) {
            final Resource baseResource = this.resourceLoader.getResource(base);

            try {
                resolvedResource = baseResource.createRelative(href);
            } catch (IOException e) {
                throw new TransformerException(
                        "Failed to find '" + href + "' relative to: " + baseResource, e);
            }

            this.logger.debug(
                    "Created resource {} for href: {} and base: {}",
                    new Object[] {resolvedResource, href, baseResource});
        } else {
            resolvedResource = this.resourceLoader.getResource(href);

            this.logger.debug("Created resource {} for href: {}", resolvedResource, href);
        }
        return resolvedResource;
    }
626028
public String resolve( Map<String, String> configuration )
    {
        StringBuilder buffer = new StringBuilder();
        append( buffer, configuration, null );
        return buffer.toString();
    }
1144463
def resolve(self, client):
        """"""

        resolve_method = getattr(client, snake_case(self.link_type))
        if self.link_type == 'Space':
            return resolve_method()
        else:
            return resolve_method(self.id)
226713
@Override
    public synchronized void resolve(JingleSession session) throws XMPPException, NotConnectedException, InterruptedException {

        setResolveInit();

        clearCandidates();

        TransportCandidate candidate = new TransportCandidate.Fixed(
                resolvedPublicIP, getFreePort());
        candidate.setLocalIp(resolvedLocalIP);

        LOGGER.fine("RESOLVING : " + resolvedPublicIP + ":" + candidate.getPort());

        addCandidate(candidate);

        setResolveEnd();

    }
1095703
public final void resolve(InetAddress value) {
		future.complete(new Tree((Tree) null, null, value));
	}
924732
@Override
  public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {

    String filename = xhtmlResourceMap.get(publicId);
    if (filename != null) {
      String resourceName = resourceFolder + "/" + filename;
      InputStream is = XHtmlEntityResolver.class.getResourceAsStream(resourceName);

      if (is == null) {
        throw new IOException("Resource '" + resourceName + "' not found in class path.");
      }

      return new InputSource(is);
    }

    return null;
  }
931102
public InputSource resolveEntity(String publicId, String systemId) throws
      SAXException, IOException {
    if (systemId == null) {
      return null;
    }

    URL url = new URL(systemId);
    String file = url.getFile();

    if ( (file != null) && (file.indexOf('/') > -1)) {
      file = file.substring(file.lastIndexOf('/') + 1);
    }

    if ("www.jdon.com".equals(url.getHost())) {
      InputStream is = getClass().getResourceAsStream("/META-INF/" + file);

      if (is == null) {
        is = getClass().getResourceAsStream("/" + file);
      }

      if (is != null) {
        return new InputSource(is);
      }
    }

    return null;
  }
399769
protected String resolveResourceContextPath(HttpServletRequest request, String resource) {
        final String resourceContextPath = this.getResourceServerContextPath();
        
        this.logger.debug("Attempting to locate resource serving webapp with context path: {}", resourceContextPath);
        
        //Try to resolve the 
        final ServletContext resourceContext = this.servletContext.getContext(resourceContextPath);
        if (resourceContext == null || !resourceContextPath.equals(resourceContext.getContextPath())) {
            this.logger.warn("Could not find resource serving webapp under context path {} ensure the resource server is deployed and cross context dispatching is enable for this web application", resourceContextPath);
            return request.getContextPath();
        }
        
        this.logger.debug("Found resource serving webapp at: {}", resourceContextPath);
        
        URL url = null;
        try {
            url = resourceContext.getResource(resource);
        }
        catch (MalformedURLException e) {
            //Ignore
        }
        
        if (url == null) {
            this.logger.debug("Resource serving webapp {} doesn't contain resource {} Falling back to the local resource.", resourceContextPath, resource);
            return request.getContextPath();
        }
        
        this.logger.debug("Resource serving webapp {} contains resource {} Using resource server.", resourceContextPath, resource);
        return resourceContextPath;
    }
1091061
protected StreamSource resolveRepositoryURI(String path)
            throws TransformerException {

        StreamSource resolvedSource = null;

        try {
            if (path != null) {
                URL url = new URL(path);
                InputStream in = url.openStream();
                if (in != null) {
                    resolvedSource = new StreamSource(in);
                }
            } else {
                throw new TransformerException("Resource does not exist. \""
                        + path + "\" is not accessible.");
            }
        } catch (MalformedURLException mfue) {
            throw new TransformerException("Error accessing resource using servlet context: "
                                         + path,
                                           mfue);
        } catch (IOException ioe) {
            throw new TransformerException("Unable to access resource at: "
                                         + path,
                                         ioe);
        }
        return resolvedSource;
    }
617285
@Override
    public Path resolve(final Path other) {
        if (other == null) {
            throw new IllegalArgumentException("other path must be specified");
        }

        if (other.isAbsolute()) {
            return other;
        }

        if (other.toString().length() == 0) {
            return this;
        }

        // Else join other to this
        final StringBuilder sb = new StringBuilder(this.path);
        if (!this.path.endsWith(ArchivePath.SEPARATOR_STRING)) {
            sb.append(ArchivePath.SEPARATOR);
        }
        sb.append(other.toString());
        final Path newPath = new ShrinkWrapPath(sb.toString(), this.fileSystem);
        return newPath;
    }
697766
@Override
    public InputSource resolveEntity(String publicId, String systemId) {
	for (int i = 0; i < Constants.DTDS_FLD.length; i++) {
	    if (publicId.equals(Constants.DTDS_FLD[i])) {
		return new InputSource(getClass().getResourceAsStream(DTD_1_0));
	    }
	}
	return null;
    }
497278
@Override
   public Bitmap  resolveImage(String filename)
   {
      Log.i(TAG, "resolveImage("+filename+")");

      try
      {
         InputStream  istream = assetManager.open(filename);
         return BitmapFactory.decodeStream(istream);
      }
      catch (IOException e1)
      {
         return null;
      }
   }
388634
private synchronized void resolveService()
    {
        T newService = null;
        final Iterator<T> it = m_serviceCollection.iterator();
        while( newService == null && it.hasNext() )
        {
            final T candidateService = it.next();
            if( !candidateService.equals( getService() ) )
            {
                newService = candidateService;
            }
        }
        setService( newService );
    }
399627
public final void resolve(String value) {
		future.complete(new Tree((Tree) null, null, value));
	}
790356
@Override
	protected List<File> resolve(String fqtn) throws Exception {
		StringTokenizer tokenizer = new StringTokenizer(fqtn, ":", false);
		String groupId = tokenizer.nextToken();
		String templateId = tokenizer.nextToken();
		String version = tokenizer.nextToken();

		Dependency dependency = new Dependency(new DefaultArtifact(groupId + ':' + templateId + ':' + version), null);

		CollectRequest collectRequest = new CollectRequest();
		collectRequest.setRoot(dependency);
		collectRequest.addRepository(local);
		collectRequest.addRepository(central);

		RepositorySystemSession session = newSession(repoSystem);

		DependencyNode node = repoSystem.collectDependencies(session, collectRequest).getRoot();
		DependencyRequest dependencyRequest = new DependencyRequest(node, null);

		repoSystem.resolveDependencies(session, dependencyRequest);

		PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
		node.accept(nlg);
		return nlg.getFiles();
	}
760149
public static Resource resolveUrl(SlingHttpServletRequest request, String url) {
        return request.getResourceResolver().getResource(url);
    }
866927
void resolveUrl() throws IOException, StorageException, KeyManagementException, NoSuchAlgorithmException{
		String tempUrl;
		if(context.isCluster){
			if(this.context.lastBalancerResponse!=null){
				tempUrl = this.context.lastBalancerResponse;				
			} else {
				//System.out.println("[-] Balancer resolve! " + this.context);
				String urlString = context.url + "?appkey=" + context.applicationKey;
				URL url = new URL(urlString);
				String balancerResponse = urlString.startsWith("https:") ? secureBalancerRequest(url) : unsecureBalancerRequest(url);
				if(balancerResponse == null){
					throw new StorageException("Cannot get response from balancer!");
				}
				JSONObject obj = (JSONObject) JSONValue.parse(balancerResponse);
				tempUrl = (String)obj.get("url");
				this.context.lastBalancerResponse = tempUrl;
			}
		} else {
			tempUrl = context.url;
		}
		//tempUrl = "https://storage-ssl-prd-useast1-s0002.realtime.co:443/";
		//this.requestUrl += this.requestUrl.substring(this.requestUrl.length() - 1).equals("/") ? this.type.toString() : "/"+this.type.toString();
		tempUrl += tempUrl.substring(tempUrl.length() - 1).equals("/") ? this.type.toString() : "/"+this.type.toString();
		//path += path.substring(path.length(), 1).equals("/") ? this.type.toString() : "/"+this.type.toString();
		this.requestUrl = new URL(tempUrl);
		//System.out.println(String.format("Rest url: %s",this.requestUrl));
	}