Get a list with all classes in the working folder (not including jars!)

@return Classes.
347261
public static Iterator<Class<?>> nonindexedClasses() {
    if(MASTER_CACHE == null) {
      initialize();
    }
    if(MASTER_CACHE.isEmpty()) {
      return Collections.emptyIterator();
    }
    return MASTER_CACHE.iterator();
  }
1170275
def obtain_check_classes(self):
        
        check_classes = set()
        for path in self.paths:
            for root, _, files in os.walk(path):
                for fi in files:
                    if not fi.endswith(".py"):
                        continue
                    path = os.path.join(root, fi)
                    check_classes = check_classes.union(set(
                        load_check_classes_from_file(path)))
        return list(check_classes)
553110
public List<Excerpt> getNestedClasses() {
    if (nestedClasses instanceof ImmutableList) {
      nestedClasses = new ArrayList<>(nestedClasses);
    }
    return Collections.unmodifiableList(nestedClasses);
  }
800618
public Iterator getAllExtentClasses()
    {
        ArrayList subTypes = new ArrayList();

        subTypes.addAll(_extents);

        for (int idx = 0; idx < subTypes.size(); idx++)
        {
            ClassDescriptorDef curClassDef = (ClassDescriptorDef)subTypes.get(idx);

            for (Iterator it = curClassDef.getExtentClasses(); it.hasNext();)
            {
                ClassDescriptorDef curSubTypeDef = (ClassDescriptorDef)it.next();

                if (!subTypes.contains(curSubTypeDef))
                {
                    subTypes.add(curSubTypeDef);
                }
            }
        }
        return subTypes.iterator();
    }
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;
   }
114025
public function getClasses()
    {
        if (!isset($this->fileClasses)) {
            $this->fileClasses = $this->findClasses();
        }

        return $this->fileClasses;
    }
174433
public ClassInfoList getSubclasses() {
        if (getName().equals("java.lang.Object")) {
            // Make an exception for querying all subclasses of java.lang.Object
            return scanResult.getAllClasses();
        } else {
            return new ClassInfoList(
                    this.filterClassInfo(RelType.SUBCLASSES, /* strictWhitelist = */ !isExternalClass),
                    /* sortByName = */ true);
        }
    }
1242505
protected List<String> classNames() {
        getLog().debug("Searching for class names including " + includes + " and excluding " + excludes);
        List<String> classNames = newStoryFinder().findClassNames(searchDirectory(), includes, excludes);
        getLog().info("Found class names: " + classNames);
        return classNames;
    }
54159
public ArrayList<PathImpl> getResources()
  {
    ArrayList<PathImpl> list = new ArrayList<PathImpl>();

    //if (exists())
    list.add(this);

    return list;
  }
438591
public Collection<JavaClassSource> allResources()
   {
      Set<JavaClassSource> result = new HashSet<>();
      for (DTOPair pair : dtos.values())
      {
         if (pair.rootDTO != null)
         {
            result.add(pair.rootDTO);
         }
         if (pair.nestedDTO != null)
         {
            result.add(pair.nestedDTO);
         }
      }
      return result;
   }
22434
public SortedSet<TypeElement> allUnnamedClasses() {
        for (PackageElement pkg : allClasses.keySet()) {
            if (pkg.isUnnamed()) {
                return allClasses.get(pkg);
            }
        }
        return new TreeSet<>(comparator);
    }
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;
		}
	}
1284961
public static String[] getAllClassPathNotInJar() {
        String[] allClassPath = getAllClassPaths();
        List<String> allClassPathNotInJar = new ArrayList<String>();
        for (String classPath : allClassPath) {
            if (classPath.endsWith("jar")) {
                continue;
            }
            allClassPathNotInJar.add(classPath);
        }
        return allClassPathNotInJar.toArray(new String[allClassPathNotInJar.size()]);
    }
1349124
public @Nonnull List<String> getJobs() {
        List<String> r = new ArrayList<>();
        r.addAll(usages.keySet());
        Collections.sort(r);
        return r;
    }
961565
public static List<Class<?>> getComponentClasses(URL jar) throws IOException {
        JarInputStream jarFile = new JarInputStream(jar.openStream());
        URLClassLoader cl = new URLClassLoader(new URL[]{jar}, Thread.currentThread().getContextClassLoader());
        List<Class<?>> idx = new ArrayList<Class<?>>();

        JarEntry jarEntry = jarFile.getNextJarEntry();
        while (jarEntry != null) {
            String classname = jarEntry.getName();
//            System.out.println(classname);
            if (classname.endsWith(".class")) {
                classname = classname.substring(0, classname.indexOf(".class")).replace('/', '.');
                try {
                    Class<?> c = Class.forName(classname, false, cl);
                    for (Method method : c.getMethods()) {
                        if ((method.getAnnotation(Execute.class)) != null) {
                            idx.add(c);
                            break;
                        }
                    }
                } catch (ClassNotFoundException ex) {
                    ex.printStackTrace();
                }
            }
            jarEntry = jarFile.getNextJarEntry();
        }
        jarFile.close();
        return idx;
    }
850138
private Class<?>[] getClassList(List<Object> objects) {
        Class<?>[] classes = new Class<?>[objects.size()];
        for (int i = 0; i < objects.size(); i++) {
            classes[i] = objects.get(i).getClass();
        }
        return classes;
    }
548223
public List<File> getClasspathFiles() {
        if (closed.get()) {
            throw new IllegalArgumentException("Cannot use a ScanResult after it has been closed");
        }
        final List<File> classpathElementOrderFiles = new ArrayList<>();
        for (final ClasspathElement classpathElement : classpathOrder) {
            final File file = classpathElement.getFile();
            if (file != null) {
                classpathElementOrderFiles.add(file);
            }
        }
        return classpathElementOrderFiles;
    }