アノテーションのクラス名を設定する。
@param className FQCN（完全限定クラス名）を指定します。
@throws IllegalArgumentException className is empty.
427458
@XmlAttribute(name="name", required=true)
    public void setClassName(String className) {
        ArgUtils.notEmpty(className, "className");
        this.className = className;
    }
982250
private boolean isJavaSystemClassName(String className) {
        if (className == null) {
            return false;
        }

        if (className.startsWith("java/") || className.startsWith("javax/")) {
            return true;
        }
        return false;
    }
800257
public static Class classForName(String name) throws ClassNotFoundException {
		try {
			return Thread.currentThread().getContextClassLoader().loadClass(name);
		}
		catch (Exception e) {
			return Class.forName(name);
		}
	}
1274039
public void setClassName(String className) {

        checkFrozen();
        if (className != null) {
            // remove leading or trailing white space
            className = className.trim();
        }
        if (!CmsStringUtil.isValidJavaClassName(className)) {
            CmsMessageContainer message = Messages.get().container(Messages.ERR_BAD_JOB_CLASS_NAME_1, className);
            if (OpenCms.getRunLevel() > OpenCms.RUNLEVEL_2_INITIALIZING) {
                throw new CmsIllegalArgumentException(message);
            } else {
                LOG.warn(message.key());
            }
        } else {
            Class<?> jobClass;
            try {
                jobClass = Class.forName(className);
                if (!I_CmsScheduledJob.class.isAssignableFrom(jobClass)) {
                    CmsMessageContainer message = Messages.get().container(
                        Messages.ERR_JOB_CLASS_BAD_INTERFACE_2,
                        className,
                        I_CmsScheduledJob.class.getName());

                    if (OpenCms.getRunLevel() > OpenCms.RUNLEVEL_2_INITIALIZING) {
                        throw new CmsIllegalArgumentException(message);
                    } else {
                        LOG.warn(message.key());
                    }

                }
            } catch (ClassNotFoundException e) {
                CmsMessageContainer message = Messages.get().container(Messages.ERR_JOB_CLASS_NOT_FOUND_1, className);
                if (OpenCms.getRunLevel() > OpenCms.RUNLEVEL_2_INITIALIZING) {
                    throw new CmsIllegalArgumentException(message);
                } else {
                    LOG.warn(message.key());
                }

            }
        }
        m_className = className;
        if (getJobName() == null) {
            // initialize job name with class name as default
            setJobName(className);
        }

    }
583031
@Override
    public String fromClassNameToShortComponentName(final String className) {
        if (LdiStringUtil.isEmpty(className)) {
            throw new EmptyRuntimeException("className");
        }
        String s = LdiStringUtil.decapitalize(LdiClassUtil.getShortClassName(className));
        if (s.endsWith(implementationSuffix)) {
            return s.substring(0, s.length() - implementationSuffix.length());
        }
        return s;
    }
409980
public synchronized Class<?> loadClass(String className) throws ClassNotFoundException {
	// if class is already loaded flush the classloader and do new classloader
	PCLBlock cl = index.get(className);
	if (cl != null) {
	    return cl.loadClass(className);
	}
	throw new ClassNotFoundException("class " + className + " not found");
    }
3948
public static Class<?> classForNameOrNull(final String className) {
        try {
            return Class.forName(className);
        } catch (final ReflectiveOperationException | LinkageError e) {
            return null;
        }
    }
429272
public static String getRendererOverride(final String classname) {
		if (StringUtils.isBlank(classname)) {
			throw new IllegalArgumentException("classname cannot be blank.");
		}

		return get().getString(RENDERER_OVERRIDE_PREFIX + classname);
	}
437548
static <T> Optional<Class<? extends T>> getClass(final String className) {
        try {
            @SuppressWarnings("unchecked")
            final Optional<Class<? extends T>> clazz = Optional.<Class<? extends T>>of((Class<T>) Class.forName(className));
            return clazz;
        } catch (final ClassNotFoundException e) {
            return Optional.empty();
        }
    }
682422
public void setClassname(final String className) throws BuildException {
    Object proc = null;
    try {
      final Class implClass = ProcessorDef.class.getClassLoader().loadClass(className);
      try {
        final Method getInstance = implClass.getMethod("getInstance");
        proc = getInstance.invoke(null);
      } catch (final Exception ex) {
        proc = implClass.newInstance();
      }
    } catch (final Exception ex) {
      throw new BuildException(ex);
    }
    setProcessor((Processor) proc);
  }
45879
public static Class<?> tryLoad(String className) {
        try {
            return Class.forName(className, false, JSFContainer.class.getClassLoader());
        } catch (ClassNotFoundException notFound) {
            return null;
        }
    }
823683
@Override
    @FFDCIgnore(ClassNotFoundException.class)
    protected final Class<?> findClass(String name) throws ClassNotFoundException {
        if (transformers.isEmpty()) {
            Class<?> clazz = null;
            Object token = ThreadIdentityManager.runAsServer();
            try {
                synchronized (getClassLoadingLock(name)) {
                    // This method may be invoked directly instead of via loadClass
                    // (e.g. when doing a "shallow" scan of the common library classloaders).
                    // So we first must check whether we've already defined/loaded the class.
                    // Otherwise we'll get a LinkageError on the second findClass call because
                    // it will attempt to define the class a 2nd time.
                    clazz = findLoadedClass(name);
                    if (clazz == null) {
                        ByteResourceInformation byteResInfo = this.findClassBytes(name);
                        clazz = definePackageAndClass(name, byteResInfo, byteResInfo.getBytes());
                    }
                }
            } catch (ClassNotFoundException cnfe) {
                // Check the common libraries.
                clazz = findClassCommonLibraryClassLoaders(name);
            } finally {
                ThreadIdentityManager.reset(token);
            }
            return clazz;
        }

        ByteResourceInformation byteResourceInformation;
        try {
            byteResourceInformation = findClassBytes(name);
        } catch (ClassNotFoundException cnfe) {
            // Check the common libraries.
            return findClassCommonLibraryClassLoaders(name);
        }

        byte[] bytes = transformClassBytes(byteResourceInformation.getBytes(), name);
        

        return definePackageAndClass(name, byteResourceInformation, bytes);
    }
1114178
@Nonnull
    public BugInstance addClass(String className, String sourceFileName) {
        ClassAnnotation classAnnotation = new ClassAnnotation(className, sourceFileName);
        add(classAnnotation);
        return this;
    }
1131590
public void setName(String n) {
    if (n == null) {
      n = this.getClass().getSimpleName() + "#" + cacheCnt++;
    }
    name = n;
  }
144347
public ClassInfoList getClassesImplementing(final String interfaceName) {
        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()");
        }
        final ClassInfo classInfo = classNameToClassInfo.get(interfaceName);
        return classInfo == null ? ClassInfoList.EMPTY_LIST : classInfo.getClassesImplementing();
    }
826360
public static Class<?> classForName(String className) {
        try {
            return Class.forName(className, false, Javers.class.getClassLoader());
        }
        catch (ClassNotFoundException ex) {
            throw new JaversException(ex);
        }
    }
987487
private final static function loadClass($fqcn)
    {
        $reflectionClass = new ReflectionClass($fqcn);
        $constants       = $reflectionClass->getConstants();

        foreach ($constants as $name => $value) {
            $instance = new $fqcn($fqcn, $name, $value);

            /* @var $instance Enum */
            if (is_callable([$instance, '__initEnum'])) {
                $instance->__initEnum();
            }

            $instanceConstructorName = '__' . $name;
            if (is_callable([$instance, $instanceConstructorName])) {
                $instance->$instanceConstructorName();
            }

            if (!isset(self::$instances[$fqcn])) {
                self::$instances[$fqcn] = [];
            }

            self::$instances[$fqcn][$name] = $instance;
        }
    }