设置映射表
@param deprelTranslatorPath 映射表路径
@return
10916
public IDependencyParser setDeprelTranslater(String deprelTranslatorPath)
    {
        deprelTranslater = GlobalObjectPool.get(deprelTranslatorPath);
        if (deprelTranslater != null) return this;

        IOUtil.LineIterator iterator = new IOUtil.LineIterator(deprelTranslatorPath);
        deprelTranslater = new TreeMap<String, String>();
        while (iterator.hasNext())
        {
            String[] args = iterator.next().split("\\s");
            deprelTranslater.put(args[0], args[1]);
        }
        if (deprelTranslater.size() == 0)
        {
            deprelTranslater = null;
        }
        GlobalObjectPool.put(deprelTranslatorPath, deprelTranslater);

        return this;
    }
907770
@Override
    public String getPathTranslated() {
        try {
            collaborator.preInvoke(componentMetaData);
            return request.getPathTranslated();
        } finally {
            collaborator.postInvoke();
        }
    }
86815
private static String getClasspathResourceAsString(String resourcePath) {
        try (InputStream is = DefaultHelperClassSourceProvider.class.getClassLoader().getResourceAsStream(resourcePath);
             java.util.Scanner s = new java.util.Scanner(is)) {
            return s.useDelimiter("\\A").hasNext() ? s.next() : "";
        } catch (IOException e) {
            throw new RuntimeException(e);
            //should never happen and if it does then all RuntimeExceptions should be caught in LambdaFactory
        }
    }
890431
@SuppressWarnings("unchecked")
    @Override
    public T get(final CharSequence path) {
        return (T) get(path, invocationContext.getTargetComponentType());
    }
28961
@Deprecated
    public static String getRelativeUnixPath(final String basePath, final String refPath) {
        return getRelativePath(basePath, refPath, UNIX_SEPARATOR);
    }
224197
@Deprecated
    public long[] internalGetCEs(CharSequence str) {
        CollationBuffer buffer = null;
        try {
            buffer = getCollationBuffer();
            boolean numeric = settings.readOnly().isNumeric();
            CollationIterator iter;
            if(settings.readOnly().dontCheckFCD()) {
                buffer.leftUTF16CollIter.setText(numeric, str, 0);
                iter = buffer.leftUTF16CollIter;
            } else {
                buffer.leftFCDUTF16Iter.setText(numeric, str, 0);
                iter = buffer.leftFCDUTF16Iter;
            }
            int length = iter.fetchCEs() - 1;
            assert length >= 0 && iter.getCE(length) == Collation.NO_CE;
            long[] ces = new long[length];
            System.arraycopy(iter.getCEs(), 0, ces, 0, length);
            return ces;
        } finally {
            releaseCollationBuffer(buffer);
        }
    }
10397
public static  String convertToExternalPath(final String path) {
        String newPath = replaceOnce(path, "/" + CONTAINER_WEBAC_ACL, "/" + FCR_ACL);

        newPath = replaceOnce(newPath, "/" + LDPCV_TIME_MAP, "/" + FCR_VERSIONS);

        newPath = replaceOnce(newPath, "/" + FEDORA_DESCRIPTION, "/" + FCR_METADATA);

        return newPath;
    }
911681
public Path getTranslatedInstance (int x, int y)
    {
        if (_source == null) {
            return new LinePath(null, new Point(_dest.x + x, _dest.y + y),
                _duration);
        } else {
            return new LinePath(_source.x + x, _source.y + y, _dest.x + x,
                _dest.y + y, _duration);
        }
    }
885008
@VisibleForTesting
    public FedoraResource getResourceFromPath(final String externalPath) {
        final Resource resource = translator().toDomain(externalPath);
        final FedoraResource fedoraResource = translator().convert(resource);

        if (fedoraResource instanceof Tombstone) {
            final String resourceURI = TRAILING_SLASH_REGEX.matcher(resource.getURI()).replaceAll("");
            throw new TombstoneException(fedoraResource, resourceURI + "/fcr:tombstone");
        }

        return fedoraResource;
    }
247834
public <T> FieldFormatter<T> getFormatter(final String fieldPath, final Class<T> requiredType) {
        FormatterHolder holder = pathMap.get(fieldPath);
        return holder != null ? holder.getFormatter(requiredType) : null;
    }
1196241
public CmsResourceTranslator getFolderTranslator() {

        String[] array = new String[0];
        if (m_folderTranslationEnabled) {
            array = new String[m_folderTranslations.size()];
            for (int i = 0; i < m_folderTranslations.size(); i++) {
                array[i] = m_folderTranslations.get(i);
            }
        }
        return new CmsResourceTranslator(array, false);
    }
153275
@Nullable
  public static TreePath findEnclosingMethodOrLambdaOrInitializer(TreePath path) {
    TreePath curPath = path.getParentPath();
    while (curPath != null) {
      if (curPath.getLeaf() instanceof MethodTree
          || curPath.getLeaf() instanceof LambdaExpressionTree) {
        return curPath;
      }
      TreePath parent = curPath.getParentPath();
      if (parent != null && parent.getLeaf() instanceof ClassTree) {
        if (curPath.getLeaf() instanceof BlockTree) {
          // found initializer block
          return curPath;
        }
        if (curPath.getLeaf() instanceof VariableTree
            && ((VariableTree) curPath.getLeaf()).getInitializer() != null) {
          // found field with an inline initializer
          return curPath;
        }
      }
      curPath = parent;
    }
    return null;
  }
27974
public String getDebugModeBuildTimeGenerationPath(String path) {

		int idx = path.indexOf("?");
		String debugModeGeneratorPath = path.substring(0, idx);
		debugModeGeneratorPath = debugModeGeneratorPath.replaceAll("\\.", "/");

		int jawrGenerationParamIdx = path.indexOf(JawrRequestHandler.GENERATION_PARAM);
		String parameter = path.substring(jawrGenerationParamIdx + JawrRequestHandler.GENERATION_PARAM.length() + 1); // Add
																														// 1
																														// for
																														// the
																														// '='
																														// character
		ResourceGenerator resourceGenerator = resolveResourceGenerator(parameter);
		String suffixPath = null;
		if (resourceGenerator instanceof SpecificCDNDebugPathResourceGenerator) {
			suffixPath = ((SpecificCDNDebugPathResourceGenerator) resourceGenerator)
					.getDebugModeBuildTimeGenerationPath(parameter);
		} else {
			suffixPath = parameter.replaceFirst(GeneratorRegistry.PREFIX_SEPARATOR, JawrConstant.URL_SEPARATOR);
		}
		return debugModeGeneratorPath + "/" + suffixPath;
	}
1266015
public String getPathTranslated()
    {
        if (_pathInfo==null || _pathInfo.length()==0)
            return null;
        if (_pathTranslated==null)
        {
            Resource resource =
                _servletHandler.getHttpContext().getBaseResource();

            if (resource==null)
                return null;

            try
            {
                resource=resource.addPath(_pathInfo);
                File file = resource.getFile();
                if (file==null)
                    return null;
                _pathTranslated=file.getAbsolutePath();
            }
            catch(Exception e)
            {
                log.debug(LogSupport.EXCEPTION,e);
            }
        }
        
        return _pathTranslated;
    }
505433
public static List<String> readLinesWithRestOrFilePathOrClasspath(
            String resourceWithRestOrFilePathOrClasspath, String charsetName) {
        return JMCollections
                .buildListByLine(getStringWithRestOrClasspathOrFilePath(
                        resourceWithRestOrFilePathOrClasspath, charsetName));
    }
1345545
function getTranslation(keyPath, locale) {
    var translation = eval('_locales.' + locale + '.' + keyPath);
    if(!translation || (translation === undefined)) {
      return null;
    }
    return translation;
  }
311955
public <C> DbxDeltaC<C> getDeltaCWithPathPrefix(Collector<DbxDeltaC.Entry<DbxEntry>, C> collector,
                                                    /*@Nullable*/String cursor, String pathPrefix,
                                                    boolean includeMediaInfo)
        throws DbxException
    {
        DbxPathV1.checkArg("path", pathPrefix);
        return _getDeltaC(collector, cursor, pathPrefix, includeMediaInfo);
    }