{@inheritDoc}
@see \Seeren\Loader\LoaderInterface::load()
332519
public function load(string $className): bool
   {
       if (($fileName = $this->fileName($className))) {
           require $fileName;
           return true;
       } 
       return false;
   }
1274309
public static function load()
    {
        if (is_null(self::$loader)) {
            // Create loader object
            self::$loader = new \PhpMyAdmin\MoTranslator\Loader();

            // Set locale
            self::$loader->setlocale(
                self::$loader->detectlocale()
            );

            // Set default text domain
            self::$loader->textdomain('sqlparser');

            // Set path where to look for a domain
            self::$loader->bindtextdomain('sqlparser', __DIR__ . '/../locale/');
        }

        if (is_null(self::$translator)) {
            // Get translator
            self::$translator = self::$loader->getTranslator();
        }
    }
587125
public function load($className)
    {
        // get namespace from className
        $namespace = substr($className, 0, strlen($this->namespace.$this->namespaceSeparator));

        // check if requested class must be loaded by this instance of loader
        if ($this->namespace === null || $this->namespace.$this->namespaceSeparator === $namespace) {
            $fileName  = '';
            $namespace = '';

            if (($lastNsPos = strripos($className, $this->namespaceSeparator)) !== false) {
                $namespace = substr($className, 0, $lastNsPos);
                $className = substr($className, $lastNsPos + 1);
                $fileName  = str_replace($this->namespaceSeparator, $this->separator, $namespace).$this->separator;
            }

            $fileName .= str_replace('_', $this->separator, $className).$this->fileExtension;

            if ($this->includePath !== null) {
                $fileName = $this->includePath.$this->separator.$fileName;
            }

            // check first if file exists and load it -> @... suppress is fasted solution ;)
            @include_once $fileName;
        }
    }
1214844
public function load($file){
        $realPath = realpath($file);

        if (!$realPath || !file_exists($realPath)) {
            throw new FileNotFoundException($realPath);
        }

        $this->cookies = file_get_contents($realPath);     
    }
54868
public function load()
    {
        $this->_checkAdapter();

        if (!class_exists($this->getClass())) {
            throw new InvalidArgumentException(
                "The loader class '{$this->getClass()}' is not defined."
            );
        }

        $reflexion = new ReflectionClass($this->getClass());

        /** @var LoaderInterface $loader */
        $args = [['adapter' => $this->_adapter]];
        $loader = $reflexion->newInstanceArgs($args);

        $className = '\Slick\Database\Schema\LoaderInterface';

        if (!($loader instanceof LoaderInterface)) {
            throw new InvalidArgumentException(
                "The loader class '{$this->getClass()}' does not " .
                "implement {$className}."
            );
        }
        return $loader->getSchema();
    }
1127626
private function load($id = null)
    {

        $this->initialize();
        $this->id = $id;

        return $this->getDataConnector()->loadResourceLink($this);

    }
1251817
public function load($l){
		$this->id=(int)$l['id'];
		$this->alias=$l['alias'];
		$this->modulescount=(int)$l['modulescount'];
		}
270251
public function load($username): UserInterface
    {
        $grav = Grav::instance();
        /** @var UniformResourceLocator $locator */
        $locator = $grav['locator'];

        // force lowercase of username
        $username = mb_strtolower($username);

        $filename = 'account://' . $username . YAML_EXT;
        $path = $locator->findResource($filename) ?: $locator->findResource($filename, true, true);
        $file = CompiledYamlFile::instance($path);
        $content = (array)$file->content() + ['username' => $username, 'state' => 'enabled'];

        $userClass = $this->className;
        $callable = function() {
            $blueprints = new Blueprints;

            return $blueprints->get('user/account');
        };

        /** @var UserInterface $user */
        $user = new $userClass($content, $callable);
        $user->file($file);

        return $user;
    }
809582
public static function load($className)
    {
        $namespace = __NAMESPACE__ . '\\';
        $length    = strlen($namespace);

        //        if (substr($className, 0, $length) !== $namespace) {
        if (0 !== strpos($className, $namespace)) {
            return;
        }

        // init() must have been called before
        assert(self::$libDir !== null);

        require self::$libDir . substr($className, $length) . self::EXTENSION;
    }
285936
public function load($resource)
    {
        $jsonDecoder = new JsonDecoder();
        $jsonDecoder->setObjectDecoding(JsonDecoder::ASSOC_ARRAY);

        $config = $jsonDecoder->decode($this->repository->get($resource)->getBody());

        // Keep track of this file being loaded to prevent infinite recursion
        $this->loadedFiles[$resource] = true;

        $this->includeDesc($config);
        $this->mergeIncludes($config);

        return $config;
    }
835048
public function load($path)
    {
        list($data, $items) = array(array(), array($path));

        if (substr((string) $path, -4) !== '.php')
        {
            $directory = new \RecursiveDirectoryIterator($path);

            $iterator = new \RecursiveIteratorIterator($directory);

            $regex = new \RegexIterator($iterator, '/^.+\.php$/i', 1);

            $items = (array) array_keys(iterator_to_array($regex));
        }

        foreach ((array) $items as $item)
        {
            $name = $this->rename($item, $path);

            $data = require $item;

            $this->set((string) $name, $data);
        }
    }
64026
protected function executeLoader(LoaderInterface $loader)
    {
        $offset = 0;

        try {

            while ($result = $loader->load($this->limit, $offset)) {

                $this->persist($result);
                $offset += $this->limit;
            }

        } catch (LoaderException $e) {
            $this->getLogger()->error($e->getMessage());
        }
    }
643409
public function load($files)
    {
        if (!is_array($files)) {
            $files = [$files];
        }
        foreach ($files as $file) {
            $file = new File($file);
            $extName = $file->extName();
            if ($extName == 'json') {
                $data = json_decode($file->readAll(), true);
                if (!$data) {
                    throw new \Exception("File '{$file}' is not valid JSON");
                }
            } else {
                $data = require (string) $file;
            }
            $this->fromArray($data);
        }
    }
1001834
public static function load($source)
    {
        self::$variables = is_array($source) ? $source : require $source;
        self::$isLoaded = true;

        self::checkRequiredVariables();
    }
722308
public function loadClass($className) {
		try {
// 			global $AUTOLOADS;
			// PHP's class' names are not case sensitive.
			$bFile = strtolower($className);

			// If the class file path is known in the our array
			if( !empty($this->classes[$bFile]) ) {
				$path	= null;
				$path	= $this->classes[$bFile];
				require_once $path;
				if( !class_exists($className, false) && !interface_exists($className, false) ) {
					throw new \Exception('Wrong use of Autoloads, the class "'.$className.'" should be declared in the given file "'.$path.'". Please use Class Loader correctly.');
				}
			}
		} catch( Exception $e ) {
			log_error($e, 'loading_class_'.$className);
		}
	}
517000
public function load($arr) {
        foreach($arr as $key=>$value) {
            if(array_key_exists($key, self::$KEYS)) {
                if($this->valid(self::$KEYS[$key], $value)) {
                    $this->$key = $value;
                }
            }
        }
    }
777368
public function loadClass($className)
	{
		if (class_exists($className, false) || interface_exists($className, false))
		{
			return false;
		}

		if($classFile = $this->classFile($className))
		{
			require $classFile;
			return true;
		}

		return false;
	}