Load a term
@param string $class
550253
public static function load($class)
    {
        $instance = new $class;
        $taxonomy_key = $instance->getTaxonomyKey();

        if (is_admin()) {
            add_action(sprintf('created_%s', $taxonomy_key), array($instance, 'addSaveHooks'));
            add_action(sprintf('edited_%s', $taxonomy_key), array($instance, 'addSaveHooks'));
            add_action(sprintf('%s_add_form_fields', $taxonomy_key), array($instance, 'addMetaBoxes'));
            add_action(sprintf('%s_edit_form_fields', $taxonomy_key), array($instance, 'addMetaBoxes'));

            add_action(sprintf('manage_edit-%s_columns', $taxonomy_key), array($instance, 'addAdminColumns'), 10, 3);
            add_action(sprintf('manage_%s_custom_column', $taxonomy_key), array($instance, 'renderAdminColumn'), 10, 3);

            // TODO add sorting
            //add_filter(sprintf('manage_edit-%s_sortable_columns', $taxonomy_key), array($instance, 'makeAdminColumnsSortable'));
            //add_filter('request', array($instance, 'sortAdminColumns'));
        }
    }
365423
public function loadClass($class)
    {
        if (!isset($this->map[$class]) && $this->isNormalTrait($class)) {
            $path = $this->getFilePathFromClassPath($class);
            $dir = dirname($path);

            if (!is_dir($dir)) {
                if (file_exists($dir)) {
                    throw new \Exception($dir . ' is a file...');
                } else {
                    mkdir($dir, 0755, true);
                }
            }

            $result = file_put_contents(
                $path, sprintf(
                    "<?php\n\nnamespace %s;\n\ntrait %s\n{\n}\n", str_replace('/', '\\', dirname(str_replace('\\', '/', $class))), pathinfo($path)['filename']
                )
            );

            if ($result !== false || $result !== '') {
                ++$this->count;
                $this->output->writeln(sprintf('Generated trait %s', $path));
            }

            $this->map[$class] = $path;
        }

        if (isset($this->map[$class])) {
            include $this->map[$class];
        }
    }
921233
protected static function loadMappings(/*# string */ $class)
    {
        // mapping status changed ?
        if (self::isStatusUpdated()) {
            self::resetMappings();
            self::setStatus(false);
        }

        // $class' mapping loaded already
        if ($class::hasMappings()) {
            return;
        }

        // load $class mapping
        $loadedClass = $class::hasLoader();
        if ($loadedClass) {
            // loader found
            $class::setMappings(
                $loadedClass::getLoader()->loadMessages($class)
            );
        } else {
            // no loader found
            $class::setMappings([]);
        }
    }
386345
public static function autoload($class)
    {
        if ($class === 'Cpdf') {
            require_once __DIR__ . "/../lib/Cpdf.php";
            return;
        }

        $prefixLength = strlen(self::PREFIX);
        if (0 === strncmp(self::PREFIX, $class, $prefixLength)) {
            $file = str_replace('\\', DIRECTORY_SEPARATOR, substr($class, $prefixLength));
            $file = realpath(__DIR__ . (empty($file) ? '' : DIRECTORY_SEPARATOR) . $file . '.php');
            if (file_exists($file)) {
                require_once $file;
            }
        }
    }
444756
public static function loadClass($class)
    {
        if (isset(self::$_classMap[$class]))
            return (bool)require sprintf('%s/%s', self::ROOT_DIR, self::$_classMap[$class]);
        return null;
    }
1368234
public static function load($class)
    {
        /* Protects us from possible remote code inclusion due to:
           https://bugs.php.net/bug.php?id=55475
           We should already be safe without this check due to the
           way this autoloader works, but this helps other autoloaders
           that use other mechanisms and may be vulnerable. */
        if (strpos($class, ":") !== false) {
            // Safer than returning false as it prevents
            // other autoloaders from ever executing...
            throw new \Exception('Possible remote code injection detected');
        }

        // need to check if there's a current map file specified ALSO.
        // this could be the first time writing it.
        $mapped = self::isMapped($class);
        if ($mapped) {
            require_once self::$map[$class];
            if (!self::loadSuccessful($class)) {
                // record this failure & keep going, we may still find it
                self::$unmapped[] = $class;
            } else {
                return true;
            }
        }

        $file = str_replace(
            array('_', '\\'),
            DIRECTORY_SEPARATOR,
            $class
        ) . '.php';
        foreach (self::$paths as $path) {
            if (file_exists($path . DIRECTORY_SEPARATOR . $file)) {
                require_once $path . DIRECTORY_SEPARATOR . $file;
                if (!self::loadSuccessful($class)) {
                    throw new \Exception(
                        'Class ' . $class . ' was not present in ' .
                        $path . DIRECTORY_SEPARATOR . $file .
                        '") [Autoload]'
                    );
                }

                if (in_array($class, self::$unmapped)) {
                    self::updateMap(
                        $class,
                        $path . DIRECTORY_SEPARATOR . $file
                    );
                }
                return true;
            }
        }

        $e = new \Exception(
            'Class ' . $class . ' could not be loaded from ' .
            $file . ', file does not exist (registered paths="' .
            implode(PATH_SEPARATOR, self::$paths) .
            '") [Autoload]'
        );
        $trace = $e->getTrace();
        if (isset($trace[2]) && isset($trace[2]['function']) &&
            in_array(
                $trace[2]['function'],
                array('class_exists', 'interface_exists')
            )) {
            return false;
        }
        if (isset($trace[1]) && isset($trace[1]['function']) &&
            in_array(
                $trace[1]['function'],
                array('class_exists', 'interface_exists')
            )) {
            return false;
        }

        // If there are other autoload functions registered,
        // let's try to play nicely with them...
        // ...otherwise, we just throw an exception.
        if (count(spl_autoload_functions()) == 1) {
            throw $e;
        }
        return false;
    }
701075
public static function load($class)
    {
        if (stripos($class, 'Phpass') === 0) {
            $file = str_replace('\\', '/', $class);

            if (file_exists(dirname(__FILE__) . '/../' . $file . '.php')) {
                require_once(dirname(__FILE__) . '/../' . $file . '.php');
            }
        }
    }
719023
public function loadClass(string $class)
    {
        if (strpos($class, 'Proxy\__Transactional__\\') !== 0) {
            return null;
        }

        if ($file = $this->findProxyFile($class)) {
            require_once $file;

            return true;
        }

        return null;
    }
24596
protected function loadStackClass($class)
    {
        $stackQuery = \Staq\Util::getStackQuery($class);
        while ($stackQuery) {
            foreach (array_keys($this->extensions) as $extensionNamespace) {
                if ($realClass = $this->getRealClass($stackQuery, $extensionNamespace)) {
                    $this->createClassAlias($class, $realClass);
                    return TRUE;
                }
            }
            $stackQuery = \Staq\Util::popStackQuery($stackQuery);
        }

        $this->createClassEmpty($class);
    }
1161183
public static function autoloader($class) {
		// Check that the class starts with "Requests"
		if (strpos($class, 'Requests') !== 0) {
			return;
		}

		$file = str_replace('_', '/', $class);
		if (file_exists(dirname(__FILE__) . '/' . $file . '.php')) {
			require_once(dirname(__FILE__) . '/' . $file . '.php');
		}
	}
1051948
public static function _autoLoad($class)
    {
        $path="";
        foreach (self::$m_classMap as $namespace=>$dir){
            if(!empty($namespace) && strpos($class, $namespace)===0){
                $namespace=rtrim($namespace,"\\");
                $class=substr($class, strlen($namespace));
                $path = rtrim($dir,"/").str_replace("\\", "/", $class) . ".php";
                break;
            }
        }
        if(file_exists($path)){
            require_once $path;
        }
    }
371307
public static function load($class)
    {
        if (substr($class, 0, 10) !== "Highlight\\") {
            return false;
        }

        $c = str_replace("\\", "/", substr($class, 10)) . ".php";
        $res = include __DIR__ . "/$c";

        return $res == 1 ? true : false;
    }
342911
public function autoload( $class ) {
		$ClassArray = explode( '\\', $class );

		if ( count( $ClassArray ) > 1 ) {

			if ( php_sapi_name() == 'cli' ) {
				$MvcPath = $this->config->get( 'path.basepath' ) . $this->config->get( 'path.mvc' );
			} else {
				$MvcPath = $this->config->get( 'path.mvc' );
			}

			//** if count $ClassArray = 3 is HMVC
			if ( count( $ClassArray ) >= 3 ) {
				$HmvcPath = '';

				for ( $i = 0; $i < count( $ClassArray ) - 2; $i ++ ) {
					$HmvcPath .= $ClassArray[ $i ] . '/';
				}

				//**        MVC Path    /     Module     Controllers/Models                         /    Class.php
				$FileLoad = $MvcPath . '/' . $HmvcPath . $ClassArray[ count( $ClassArray ) - 2 ] . '/' . $ClassArray[ count( $ClassArray ) - 1 ] . '.php';
			} else {
				//**        MVC Path    /    Controller/Models /    Class.php
				$FileLoad = $MvcPath . '/' . $ClassArray[0] . '/' . $ClassArray[1] . '.php';
			}

			if ( file_exists( $FileLoad ) ) {
				include $FileLoad;
			}

		}

	}
204280
private function loadFilter($class)
    {
        if (isset($this->filtersInstances[$class])) {
            return true;
        }

        $filter = $this->objectsFactory->buildFilter($class, $this->loadedConfigurator);

        if ($filter === false) {
            $this->loadedLogger->warning('Could not load ' . $class . ' filter.');

            return false;
        }

        $this->filtersInstances[$class] = $filter;
        $this->loadedLogger->debug('Filter ' . $class . ' found & loaded.');

        return true;
    }
832180
public function loadClass($className)
    {
        if ($filePath = $this->resolveFileName($className)) {
            if ($this->getFailureFlag() & self::FAIL_GRACEFULLY) {
                if ($this->classFileExists($filePath)) {
                    require_once $filePath;
                }
            } else {
                require_once $filePath;
            }
        }
    }
793392
public function loadClass(string $class): ?bool
    {
        if ($file = $this->findFile($class)) {
            _includeClassFile($file);
            return true;
        }

        return null;
    }
1311944
private function loadCommand($class) {
        $controller = new $class();
        if (!is_a($controller, '\\mpf\\cli\\Command')) {
            $this->critical('Command `' . $class . '` must extend \\mpf\\cli\\Command!', array(
                'requestedController' => $this->request()->getController(),
                'requestedModule' => $this->request()->getModule()
            ));
            return null;
        }
        return $controller;
    }