Returns the classnames that can be loaded for the given {@code Extension} (with dependencies).

@param classname the classname of the extension
@return the classnames that can be loaded
@since 2.4.3
@see #hasExtensionsWithDeps()
439211
public AddOnClassnames getExtensionAddOnClassnames(String classname) {
		if (extensionsWithDeps.isEmpty() || classname == null || classname.isEmpty()) {
			return AddOnClassnames.ALL_ALLOWED;
		}

		for (ExtensionWithDeps extension : extensionsWithDeps) {
			if (classname.equals(extension.getClassname())) {
				return extension.getAddOnClassnames();
			}
		}
		return AddOnClassnames.ALL_ALLOWED;
	}
776648
public static @CheckForNull <T extends Descriptor> T findByDescribableClassName(Collection<? extends T> list, String className) {
        for (T d : list) {
            if(d.clazz.getName().equals(className))
                return d;
        }
        return null;
    }
1305550
private static ImmutableList<String> getClassNames(String qualifiedName) {
    ImmutableList.Builder<String> classNames = ImmutableList.builder();
    List<String> parts = DOT_SPLITTER.splitToList(qualifiedName);
    for (int i = 0; i < parts.size(); i++) {
      String part = parts.get(i);
      if (isClassOrConstantName(part)) {
        classNames.add(DOT_JOINER.join(parts.subList(0, i + 1)));
      }
    }
    return classNames.build();
  }
1351709
public ClassInfoList getSubclasses(final String superclassName) {
        if (closed.get()) {
            throw new IllegalArgumentException("Cannot use a ScanResult after it has been closed");
        }
        if (!scanSpec.enableClassInfo) {
            throw new IllegalArgumentException("Please call ClassGraph#enableClassInfo() before #scan()");
        }
        if (superclassName.equals("java.lang.Object")) {
            // Return all standard classes (interfaces don't extend Object)
            return getAllStandardClasses();
        } else {
            final ClassInfo superclass = classNameToClassInfo.get(superclassName);
            return superclass == null ? ClassInfoList.EMPTY_LIST : superclass.getSubclasses();
        }
    }
687195
public static String getPackageName(String className) {
        int i = className.lastIndexOf(".");
        String packageName = "";
        if (i > -1) {
            packageName = className.substring(0, i);
        }
        return packageName;
    }
66443
private List<ClassNameWrapper> getLocalClassNames (String packageName) {
    
        if (packageName == null || packageName.equals("")) {
            return Collections.emptyList();
        }
        
        String folder = packageName.replace('.', '/');
        URL local = AddOnLoader.class.getClassLoader().getResource(folder);
        if (local == null) {
            return Collections.emptyList();
        }
        String jarFile = null;
        if (local.getProtocol().equals("jar")) {
            jarFile = local.toString().substring("jar:".length());
            int pos = jarFile.indexOf("!");
            jarFile = jarFile.substring(0, pos);
            
            try {
                // ZAP: Changed to take into account the package name
                return getJarClassNames(this.getClass().getClassLoader(), new File(new URI(jarFile)), packageName);
            } catch (URISyntaxException e) {
            	logger.error(e.getMessage(), e);
            }
        } else {
            try {
                // ZAP: Changed to pass a FileFilter (ClassRecurseDirFileFilter)
                // and to pass the "packageName" with the dots already replaced.
                return parseClassDir(this.getClass().getClassLoader(), new File(new URI(local.toString())),
                              packageName.replace('.', File.separatorChar),
                              new ClassRecurseDirFileFilter(true));
            } catch (URISyntaxException e) {
            	logger.error(e.getMessage(), e);
            }
        }
        return Collections.emptyList();
    }
372265
public static String transformClassName(String className) {
        int lastDot = className.lastIndexOf('.');
        if (lastDot >= 0) {
            String pkg = className.substring(0, lastDot);
            if (!isUnlikelyToBeRenamed(pkg)) {
                className = className.substring(lastDot + 1);
            }
        }
        return className;
    }
305323
public static Class<?> findClassFromClassLoaders(final String className, final Iterable<ClassLoader> classLoaders)
        throws ClassNotFoundException, IllegalArgumentException {
        // Delegate
        return ClassLoaderSearchUtil.findClassFromClassLoaders(className, classLoaders);
    }
422062
public static String [] splitClassname ( String classname ) {
        classname = canonicalizeClassName( classname );

        int i=classname.lastIndexOf(".");
        String classn, packn;
        if ( i == -1 )  {
            // top level class
            classn = classname;
            packn="<unpackaged>";
        } else {
            packn = classname.substring(0,i);
            classn = classname.substring(i+1);
        }
        return new String [] { packn, classn };
    }
185928
public static URLClassLoader getClassLoaderForExtension(File extension, boolean useExtensionClassloaderFirst)
  {
    return loadersMap.computeIfAbsent(
        extension,
        theExtension -> makeClassLoaderForExtension(theExtension, useExtensionClassloaderFirst)
    );
  }
1246391
@Pure
	public static Collection<Class<?>> getPackageClasses(String packageName) {
		final Collection<Class<?>> classes = new ArrayList<>();

		final String[] entries = System.getProperty("java.class.path") //$NON-NLS-1$
				.split(Pattern.quote(System.getProperty("path.separator"))); //$NON-NLS-1$
		String lentry;

		for (final String path : entries) {
			lentry = path.toLowerCase();
			if (lentry.endsWith(".jar") || lentry.endsWith(".war")) { //$NON-NLS-1$ //$NON-NLS-2$
				getPackageClassesFromJar(classes, path, packageName);
			} else {
				getPackageClassesFromFileSystem(classes, path, packageName);
			}

		}

		return classes;
	}
1154466
protected List<Class<?>> getExtensionClasses() {
		return Lists.<Class<?>> newArrayList(
			ArrayExtensions.class,
			BigDecimalExtensions.class,
			BigIntegerExtensions.class,
			BooleanExtensions.class,
			ByteExtensions.class,
			CharacterExtensions.class,
			CollectionExtensions.class,
			ComparableExtensions.class,
			DoubleExtensions.class,
			FloatExtensions.class,
			FunctionExtensions.class,
			IntegerExtensions.class,
			IterableExtensions.class,
			IteratorExtensions.class,
			ListExtensions.class,
			LongExtensions.class,
			MapExtensions.class,
			ObjectExtensions.class,
			ProcedureExtensions.class,
			ShortExtensions.class,
			StringExtensions.class);
	}
1087255
public static String getJustClassName(String classname)
   {
      int index = classname.lastIndexOf('.');
      if (index < 0)
         index = 0;
      else index = index + 1;
      return classname.substring(index);
   }
1176999
public static ArchivePath getFullPathForClassResource(String className) {
        String classResourceDelimiter = className.replaceAll(DELIMITER_CLASS_NAME_PATH, DELIMITER_RESOURCE_PATH);
        String classFullPath = classResourceDelimiter + EXTENSION_CLASS;
        return new BasicPath(classFullPath);
    }
1038914
public List<Extension> getLoadedExtensionsWithDeps() {
		List<String> classnames = getExtensionsWithDeps();
		ArrayList<Extension> loadedExtensions = new ArrayList<>(extensionsWithDeps.size());
		for (Extension extension : getLoadedExtensions()) {
			if (classnames.contains(extension.getClass().getCanonicalName())) {
				loadedExtensions.add(extension);
			}
		}
		loadedExtensions.trimToSize();
		return loadedExtensions;
	}
731889
public static String getFullClassName(String domainName, String packageName, String className) {
       if (packageName != null)
           if (packageName.length() > 0) {
               if (packageName.charAt(packageName.length() - 1) != '.')
                   packageName = packageName + '.';
           }
       if (className != null)
           if (className.length() > 0) {
               if (className.indexOf('.') == -1)
                   if (packageName != null)
                       className = packageName + className;
               if (className.charAt(0) == '.')
               {
               	if (domainName != null)
               	{
               		if (domainName.endsWith("."))
               			className = domainName + className.substring(1);
               		else
               			className = domainName + className;
               	}
               	else
                       className = Constant.ROOT_PACKAGE + className.substring(1);
               }
           }
       return className;
   }
73370
protected function loadExtension($ClassName)
    {

        try {
            $reflectionClass = new  \ReflectionClass($ClassName);
            if(!$reflectionClass->isInstantiable())
                throw new \OWeb\manage\exceptions\Extension("The Extension is still abstract");

            $extension = new $ClassName();

            if ($extension instanceof \OWeb\types\Extension) {
                $this->registerExtension($extension, $ClassName);

                return $extension;
            } else
                throw new \OWeb\manage\exceptions\Extension("The Extension isn't an instance of : \OWeb\\types\Extension");

        } catch (\Exception $ex) {
            throw new \OWeb\manage\exceptions\Extension("The extension couldn't be loaded.", 0, $ex);
        }
    }