このクラスのインスタンスを返します。

@static
@param	string	$class_name	保持するクラス名
@return	\ickx\fw2\container\DI	このクラスのインスタンス
13650
protected static function _GetInstance ($class_name) {
		return (isset(static::$_instanceList[$class_name])) ? static::$_instanceList[$class_name] : static::$_instanceList[$class_name] = new static($class_name);
	}
1053303
function helper($helper_name) {
        if(array_key_exists($helper_name, $this->helpers)) {
            return $this->helpers[$helper_name];
        }
        else {
            $classname = 'Helper_' . ucwords($helper_name);
            return new $classname($this->modules, $this->server, $this->request, $this->security);
        }
    }
728779
protected function get_class_setting( $class_name, $add_namespace = '' ) {
		if ( isset( $this->_cache[ $add_namespace . $class_name ] ) ) {
			return $this->_cache[ $add_namespace . $class_name ];
		}
		$namespaces = $this->get_namespaces();
		if ( ! empty( $namespaces ) ) {
			foreach ( $namespaces as $namespace ) {
				$class = rtrim( $namespace, '\\' ) . '\\' . $add_namespace . $class_name;
				if ( class_exists( $class ) ) {
					$this->_cache[ $add_namespace . $class_name ] = [ $class, $add_namespace ];

					return $this->_cache[ $add_namespace . $class_name ];
				}
			}
		}

		return false;
	}
1176882
public function getNamespace($class_name)
	{
		$class_name = trim($class_name, '\\');
		if ($last_separator = strrpos($class_name, '\\'))
		{
			return substr($class_name, 0, $last_separator + 1);
		}
		return '';
	}
857990
public static function denamespace($class_name)
	{
		$class_name = trim($class_name, '\\');
		if ($last_separator = strrpos($class_name, '\\'))
		{
			$class_name = substr($class_name, $last_separator + 1);
		}
		return $class_name;
	}
691818
public function GetClassChilds($class_name, $namespace="")
    {   
        $childs = array();
        
        if(!$namespace)
        {
            $components = $this->GetComponents($class_name);
            
            if($components->HasNamespace())
            {
                $namespace = $components->namespace;
                $class_name = $components->type;
            }
            else
            {
                $namespace = "\\";
            }
        }
        
        $parent_class = "";
        
        if($namespace != "\\")
            $parent_class .= $namespace . "\\" . $class_name;
        else
            $parent_class .= $class_name;
        
        foreach($this->headers as $header_object)
        {
            foreach($header_object->namespaces as $namespace_object)
            {
                foreach($namespace_object->classes as $class_object)
                {
                    if(in_array($parent_class, $class_object->parents))
                    {
                        $childs[$class_object->name] = $class_object;
                        
                        $childs += $this->GetClassChilds(
                            $class_object->name,
                            $class_object->namespace->name
                        );
                    }
                }
            }
        }
        
        return $childs;
    }
1190042
private function exprClass(Node $class_name) {
    $colon_node = new PartialNode();
    $this->mustMatch(T_DOUBLE_COLON, $colon_node);
    if ($this->currentType === T_STRING) {
      $class_constant = $this->mustMatchToken(T_STRING);
      if ($this->currentType === '(') {
        return $this->classMethodCall($class_name, $colon_node, $class_constant);
      }
      else {
        return $this->classConstant($class_name, $colon_node, $class_constant);
      }
    }
    elseif ($this->currentType === T_CLASS) {
      return $this->classNameScalar($class_name, $colon_node);
    }
    else {
      return $this->classVariable($class_name, $colon_node);
    }
  }
507561
public function setClassName($class_name)
    {
        if ($class_name === null) {
            throw new ENabuCoreException(
                    ENabuCoreException::ERROR_NULL_VALUE_NOT_ALLOWED_IN,
                    array("\$class_name")
            );
        }

        $implements_list = class_implements($class_name, true);

        if (is_array($implements_list) &&
            array_search('nabu\http\interfaces\INabuHTTPResponseRender', $implements_list)
        ) {
            $this->setValue("nb_http_render_descriptor_class_name", $class_name);
        } else {
            throw new ENabuCoreException(ENabuCoreException::ERROR_INVALID_RENDER_DESCRIPTOR_CLASS);
        }

        return $this;
    }
866067
static function load($class_name)
    {
        if (stream_resolve_include_path(
            "modules/archi/includes/".$class_name.".class.php"
        )) {
            include_once "modules/archi/includes/".$class_name.".class.php";
        } else if (stream_resolve_include_path(
            __DIR__."/frameworkClasses/".$class_name.".class.php"
        )) {
            include_once __DIR__."/frameworkClasses/".$class_name.".class.php";
        }
    }
54007
public function getFirstDescendant($class_name)
    {
        if (!class_exists($class_name) && !interface_exists($class_name)) {
            return null;
        }

        $out = null;

        foreach ($this->children as $child_widget) {
            if ($child_widget instanceof $class_name) {
                $out = $child_widget;
                break;
            }

            if ($child_widget instanceof SwatUIParent) {
                $out = $child_widget->getFirstDescendant($class_name);
                if ($out !== null) {
                    break;
                }
            }
        }

        return $out;
    }
168669
public function hasClass($class_name)
    {
        foreach ($this->nodes as $node) {
            if ($node instanceof \DOMElement && $node_class_attr = $node->getAttribute('class')) {
                $node_classes = explode(' ', $node_class_attr);
                if (\in_array($class_name, $node_classes, true)) {
                    return true;
                }
            }
        }

        return false;
    }
638774
public function getLogger($class_name = UNDEFINED)
    {
        if (is_null($this->logger)) {
            $this->logger = $this->add($class_name === UNDEFINED
                                            ? $this->logger_class
                                            : $class_name);
        }

        return $this->logger;
    }
753371
public static function isClassInstance($object, $class_name)
    {
        if (class_exists($class_name) && is_object($object)) {
            return (bool) ($object instanceof $class_name);
        }
        return false;
    }
925116
public function getFileAnalyzerForClassLike($fq_class_name)
    {
        $fq_class_name_lc = strtolower($fq_class_name);

        $file_path = $this->codebase->scanner->getClassLikeFilePath($fq_class_name_lc);

        $file_analyzer = new FileAnalyzer(
            $this,
            $file_path,
            $this->config->shortenFileName($file_path)
        );

        return $file_analyzer;
    }
939667
public function get(string $class_name, array $args = [])
    {
        $class_name = ltrim($class_name, '\\');
        $class_key  = strtolower($class_name);

        if (isset($this->instances[$class_key])) {
            return $this->instances[$class_key];
        }
        if (!isset($this->closures[$class_key])) {
            $this->closures[$class_key] = $this->getClosure($class_name, $class_key);
        }
        return $this->closures[$class_key]($args);
    }
450030
public static function implementsInterface($class_name, $interface_name)
    {
        if (is_object($class_name)) {
            $class_name = get_class($class_name);
        }
        if (class_exists($class_name)) {
            $interfaces = class_implements($class_name);
            return (bool) in_array($interface_name, $interfaces) || in_array(trim($interface_name, '\\'), $interfaces);
        }
        return false;
    }
544382
final public static function getInstance($class_name = null)
    {
        if (is_null($class_name)) {
            $class_name = get_called_class();
        }

        $reflection = new \ReflectionClass($class_name);
        if (!$reflection->isInstantiable()) {
            throw new \Exception("The constructor of the class '$class_name' must be protected", 1);
        }

        if (empty(self::$pool[$class_name])) {
            self::$pool[$class_name] = new $class_name();
        }

        return self::$pool[$class_name];
    }