Gets the scheme from the schemeMap.
518061
public PathImpl get(String scheme)
  {
    ConcurrentHashMap<String,SchemeRoot> map = getMap();
    
    SchemeRoot root = map.get(scheme);

    if (root == null) {
      PathImpl rootPath = createLazyScheme(scheme);
      
      if (rootPath != null) {
        map.putIfAbsent(scheme, new SchemeRoot(rootPath));
        root = map.get(scheme);
      }
    }
    
    PathImpl path = null;
    
    if (root != null) {
      path = root.getRoot();
    }
    
    if (path != null) {
      return path;
    }
    else {
      return new NotFoundPath(this, scheme + ":");
    }
  }
894403
def get_color_scheme(name):
    """"""
    name = name.lower()
    scheme = {}
    for key in COLOR_SCHEME_KEYS:
        try:
            scheme[key] = CONF.get('appearance', name+'/'+key)
        except:
            scheme[key] = CONF.get('appearance', 'spyder/'+key)
    return scheme
174333
@Override
  public PathImpl schemeWalk(String userPath,
                         Map<String,Object> attributes,
                         String filePath,
                         int offset)
  {
    int p = filePath.indexOf('!', offset);
    String backingPath;
    String jarPath;

    if (p > 0) {
      backingPath = filePath.substring(offset, p);
      jarPath = filePath.substring(p + 1);
    }
    else {
      backingPath = filePath.substring(offset);
      jarPath = "";
    }

    PathImpl backing = VfsOld.lookup(backingPath);

    return JarPath.create(backing).lookup(jarPath);
  }
91111
@Override
    public void setScheme(byte[] scheme) throws UnsupportedSchemeException {
        SchemeValues val = SchemeValues.find(scheme, 0, scheme.length);
        if (null == val) {
            throw new UnsupportedSchemeException("Illegal scheme " + GenericUtils.getEnglishString(scheme));
        }
        setScheme(val);
    }
1176000
public SchemeRoot put(String scheme, SchemeRoot root)
  {
    return getUpdateMap().put(scheme, root);
  }
31607
function extractSourceMap(bundleContents) {
  var start = bundleContents.lastIndexOf('//# sourceMappingURL');
  var sourceMapComment = start !== -1 ? bundleContents.substring(start) : '';

  return sourceMapComment && convert.fromComment(sourceMapComment);
}
778945
public Map getMapOfValue(Object key) {
		for (Scope cur=this; cur!=null; cur=cur.parent) {
			if (cur.data != null && cur.data.containsKey(key)) {
				return cur.data;
			}
		}
		return null;
	}
390689
private Context getURLContext(String name) throws NamingException {
        int schemeIndex = name.indexOf(":");
        if (schemeIndex != -1) {
            String scheme = name.substring(0, schemeIndex);
            return NamingManager.getURLContext(scheme, env);
        }

        return null;
    }
1043316
@Override
    public Map<String, Object> getApplicationMap()
    {
        if (_applicationMap == null)
        {
            _applicationMap = new ApplicationMap(_servletContext);
        }
        return _applicationMap;
    }
498823
public CmsSiteMatcher forDifferentScheme(String scheme) {

        try {
            URI uri = new URI(getUrl());
            URI changedUri = new URI(scheme, uri.getAuthority(), uri.getPath(), uri.getQuery(), uri.getFragment());
            CmsSiteMatcher res = new CmsSiteMatcher(changedUri.toString(), m_timeOffset);
            res.setRedirect(m_redirect);
            return res;
        } catch (Exception e) {
            LOG.error(e.getLocalizedMessage(), e);
            return null;
        }
    }
1098769
public PathImpl createRoot(SchemeMap schemeMap)
  {
    FilesystemPath restriction = (FilesystemPath) copy();

    restriction._schemeMap = schemeMap;
    restriction._root = this;
    restriction._pathname = "/";
    restriction._userPath = "/";

    return restriction;
  }
410666
def get_by_scheme(path, lookup, default):
    
    parsed = urlparse(path)
    class_name = lookup.get(parsed.scheme, default)
    if class_name is None:
        raise NotImplementedError("No implementation for scheme " + parsed.scheme)
    return class_name
663772
public static policymap[] get(nitro_service service, String mappolicyname[]) throws Exception{
		if (mappolicyname !=null && mappolicyname.length>0) {
			policymap response[] = new policymap[mappolicyname.length];
			policymap obj[] = new policymap[mappolicyname.length];
			for (int i=0;i<mappolicyname.length;i++) {
				obj[i] = new policymap();
				obj[i].set_mappolicyname(mappolicyname[i]);
				response[i] = (policymap) obj[i].get_resource(service);
			}
			return response;
		}
		return null;
	}
19620
public UrlBuilder withScheme(String scheme) {
        if (scheme == null || scheme.isEmpty()) {
            this.scheme = null;
        } else {
            with(scheme, UrlTokenizerState.SCHEME);
        }
        return this;
    }
131825
private LinkedHashMap<PrefixedName,DTDElement> getElementMap() {
        LinkedHashMap<PrefixedName,DTDElement> m = mElements;
        if (m == null) {
            /* Let's try to get insert-ordered Map, to be able to
             * report redefinition problems in proper order when validating
             * subset compatibility
             */
            mElements = m = new LinkedHashMap<PrefixedName,DTDElement>();
        }
        return m;
    }
941818
SubjectScheme getSubjectScheme(final Element root) {
        subjectSchemeReader.reset();
        logger.debug("Loading subject schemes");
        final List<Element> subjectSchemes = toList(root.getElementsByTagName("*"));
        subjectSchemes.stream()
                .filter(SUBJECTSCHEME_ENUMERATIONDEF::matches)
                .forEach(enumerationDef -> {
                    final Element schemeRoot = ancestors(enumerationDef)
                            .filter(SUBMAP::matches)
                            .findFirst()
                            .orElse(root);
                    subjectSchemeReader.processEnumerationDef(schemeRoot, enumerationDef);
                });
        return subjectSchemeReader.getSubjectSchemeMap();
    }
552294
private static Iterable<String> getParametersFromMap(final Map<String, String> paramMap, final boolean strict) {
        return Iterables.transform(paramMap.entrySet(), new Function<Map.Entry<String, String>, String>() {
            @Override public String apply(final Map.Entry<String, String> input) {
                return input == null ? null : ENTRY_JOINER.join(UriEscaper.escapeQueryParam(input.getKey(), strict),
                                                                UriEscaper.escapeQueryParam(input.getValue(), strict));
            }
        });
    }