Gets the pathClasses.
A Map containing hints about what Class to be used for what path segment
If local instance not set, try parent Criteria's instance.  If this is
the top-level Criteria, try the m_query's instance
@return Returns a Map
13539
public Map getPathClasses()
	{
		if (m_pathClasses.isEmpty())
		{
			if (m_parentCriteria == null)
			{
				if (m_query == null)
				{
					return m_pathClasses;
				}
				else
				{
					return m_query.getPathClasses();
				}
			}
			else
			{
				return m_parentCriteria.getPathClasses();
			}
		}
		else
		{
			return m_pathClasses;
		}
	}
471391
public Class getRootDeclarationClass() {
        ConfigPath res = this;
        while (res.getRoot() != null) {
            res = res.getRoot();
        }
        return res.getDeclarationClass();
    }
518413
public static Map<String, Class<? extends ParaObject>> getCoreClassesMap() {
		if (CORE_CLASSES.isEmpty()) {
			try {
				CORE_PARA_CLASSES.putAll(SCANNER.getComponentClasses(ParaObject.class.getPackage().getName()));
				CORE_CLASSES.putAll(CORE_PARA_CLASSES);
				if (!Config.CORE_PACKAGE_NAME.isEmpty()) {
					CORE_CLASSES.putAll(SCANNER.getComponentClasses(Config.CORE_PACKAGE_NAME));
				}
				logger.debug("Found {} ParaObject classes: {}", CORE_CLASSES.size(), CORE_CLASSES);
			} catch (Exception ex) {
				logger.error(null, ex);
			}
		}
		return Collections.unmodifiableMap(CORE_CLASSES);
	}
501130
@Pure
	public List<S> getPath() {
		if (this.path == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableList(this.path);
	}
1002505
public function getMetaClasses()
    {
        $returnValue = null;

        
        $returnValue = new core_kernel_classes_ContainerCollection(new core_kernel_classes_Container(__METHOD__),__METHOD__);
        
        $classClass = new core_kernel_classes_Class(OntologyRdfs::RDFS_CLASS);
        foreach($classClass->getSubClasses(true) as $uri => $subClass){
        	$returnValue->add($subClass);
        }
		

        return $returnValue;
    }
184325
public Map<String, Object> getLocals() {
    if (locals == null || locals.length == 0) {
      return null;
    }

    Map<String, Object> localsMap = new HashMap<>();
    for (LocalVariable localVariable : locals) {
      if (localVariable != null) {
        localsMap.put(localVariable.getName(), localVariable.getValue());
      }
    }

    return localsMap;
  }
849052
public static ArrayList<String> getClassPathList()
  {
    if (_classPathList != null)
      return _classPathList;

    ArrayList<String> list = new ArrayList<String>();

    String classPath = getClassPath();
    String []classPathArray
      = classPath.split("[" + getPathSeparatorChar() + "]");

    for (int i = 0; i < classPathArray.length; i++) {
      if (! list.contains(classPathArray[i]))
        list.add(classPathArray[i]);
    }

    _classPathList = list;

    return _classPathList;
  }
246646
private static List<String> determinePaths(final MethodResult methodResult) {
        final List<String> paths = new LinkedList<>();
        MethodResult currentMethod = methodResult;

        while (true) {
            addNonBlank(currentMethod.getPath(), paths);
            final ClassResult parentClass = currentMethod.getParentResource();

            if (parentClass == null)
                break;

            currentMethod = parentClass.getParentSubResourceLocator();
            if (currentMethod == null) {
                addNonBlank(parentClass.getResourcePath(), paths);
                break;
            }
        }

        Collections.reverse(paths);
        return paths;
    }
689635
public String getCompleteClassPath() {
		StringBuilder sb = new StringBuilder();
		if (baseClassPath != null) {
			sb.append(baseClassPath + File.pathSeparator);
		}
		for (Class<? extends Plugin> pluginClass : implementations.keySet()) {
			Set<PluginContext> set = implementations.get(pluginClass);
			for (PluginContext pluginContext : set) {
				sb.append(pluginContext.getClassLocation() + File.pathSeparator);
			}
		}
		return sb.toString();
	}
977842
@Override
	public Set<Class<?>> getClasses()
	{
		Set<Class<?>> classes = new HashSet<>();
		classes.add(HelloResource.class);
		return classes;
	}
580265
public static List<String> getClasses() {
    ArrayList<String> names = new ArrayList<String>();
    if(_init._h2oJar != null) {
      for( Enumeration<ZipEntry> e = (Enumeration) _init._h2oJar.entries(); e.hasMoreElements(); ) {
        String name = e.nextElement().getName();
        if( name.endsWith(".class") )
          names.add(name);
      }
    } else
      findClasses(new File(CLASSES), names);

    for( int i = 0; i < names.size(); i++ ) {
      String n = names.get(i);
      names.set(i, Utils.className(n));
    }
    return names;
  }
1358756
@Override
	protected Set<Class<? extends Annotation>> getSupportedAnnotationClasses() {
		Set<Class<? extends Annotation>> annotations = new LinkedHashSet<Class<? extends Annotation>>();

		annotations.add(BindType.class);
		annotations.add(BindDataSource.class);
		annotations.add(BindDataSourceOptions.class);
		annotations.add(BindSqlType.class);
		annotations.add(BindDao.class);
		annotations.add(BindDaoMany2Many.class);
		annotations.add(BindGeneratedDao.class);

		return annotations;
	}
377846
public List<IfClassAvailable<Exclude<T>>> getAllIfClassAvailable()
   {
      List<IfClassAvailable<Exclude<T>>> list = new ArrayList<IfClassAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-available");
      for(Node node: nodeList)
      {
         IfClassAvailable<Exclude<T>>  type = new IfClassAvailableImpl<Exclude<T>>(this, "if-class-available", childNode, node);
         list.add(type);
      }
      return list;
   }
419931
public ClassInfo getSuperclass() {
        final Set<ClassInfo> superClasses = relatedClasses.get(RelType.SUPERCLASSES);
        if (superClasses == null || superClasses.isEmpty()) {
            return null;
        } else if (superClasses.size() > 2) {
            throw new IllegalArgumentException("More than one superclass: " + superClasses);
        } else {
            final ClassInfo superclass = superClasses.iterator().next();
            if (superclass.getName().equals("java.lang.Object")) {
                return null;
            } else {
                return superclass;
            }
        }
    }
628324
public java.util.List<TransitGatewayRouteTablePropagation> getTransitGatewayRouteTablePropagations() {
        if (transitGatewayRouteTablePropagations == null) {
            transitGatewayRouteTablePropagations = new com.amazonaws.internal.SdkInternalList<TransitGatewayRouteTablePropagation>();
        }
        return transitGatewayRouteTablePropagations;
    }
463337
public static List getClasspathComponents()
    {
        List components = new LinkedList();

        // walk the classloader hierarchy, trying to get all the components we can
        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        while ((null != cl) && (cl instanceof URLClassLoader))
        {
            URLClassLoader ucl = (URLClassLoader) cl;
            components.addAll(getUrlClassLoaderClasspathComponents(ucl));

            try
            {
                cl = ucl.getParent();
            }
            catch (SecurityException se)
            {
                cl = null;
            }
        }

        // walking the hierarchy doesn't guarantee we get everything, so
        // lets grab the system classpath for good measure.
        String classpath = System.getProperty("java.class.path");
        String separator = System.getProperty("path.separator");
        StringTokenizer st = new StringTokenizer(classpath, separator);
        while (st.hasMoreTokens())
        {
            String component = st.nextToken();
            // Calling File.getPath() cleans up the path so that it's using
            // the proper path separators for the host OS
            component = getCanonicalPath(component);
            components.add(component);
        }

        // Set removes any duplicates, return a list for the api.
        return new LinkedList(new HashSet(components));
    }
943472
public List<GroovyClassDoc> getParentClasses() {
        List<GroovyClassDoc> result = new LinkedList<GroovyClassDoc>();
        if (isInterface()) return result;
        result.add(0, this);
        GroovyClassDoc next = this;
        while (next.superclass() != null && !"java.lang.Object".equals(next.qualifiedTypeName())) {
            next = next.superclass();
            result.add(0, next);
        }
        GroovyClassDoc prev = next;
        Class nextClass = getClassOf(next.qualifiedTypeName());
        while (nextClass != null && nextClass.getSuperclass() != null && !Object.class.equals(nextClass)) {
            nextClass = nextClass.getSuperclass();
            GroovyClassDoc nextDoc = new ExternalGroovyClassDoc(nextClass);
            if (prev instanceof SimpleGroovyClassDoc) {
                SimpleGroovyClassDoc parent = (SimpleGroovyClassDoc) prev;
                parent.setSuperClass(nextDoc);
            }
            result.add(0, nextDoc);
            prev = nextDoc;
        }
        if (!result.get(0).qualifiedTypeName().equals("java.lang.Object")) {
            result.add(0, new ExternalGroovyClassDoc(Object.class));
        }
        return result;
    }