Load an image from a system path

@param bool $name File name
@param bool $path File path

@return void -
164036
public function getFromPath($name = false, $path = false)
    {
        if ($path && $name) {
            $this->img       = $path . '/' . $name;
            $this->handle    = new Upload($this->img);
            $this->_new_name = $this->s3->sanitizeFilename(uniqid("", true) . $this->handle->file_src_name);
        }
    }
1012625
private function loadLanguageFile($name)
    {
        /** @var System $system */
        $system = $this->framework->getAdapter(System::class);
        $system->loadLanguageFile($name);
    }
357077
protected function loadFile($name)
    {
        $blueprint = new Blueprint($name);

        if (\is_array($this->search) || \is_object($this->search)) {
            // Page types.
            $blueprint->setOverrides($this->search);
            $blueprint->setContext('blueprints://pages');
        } else {
            $blueprint->setContext($this->search);
        }

        return $blueprint->load()->init();
    }
837212
protected function loadRoutesFrom($path): void
    {
        if (Str::contains($this->app->version(), 'Lumen')) {
            require realpath($path);

            return;
        }

        parent::loadRoutesFrom($path);
    }
716932
private function loadData(string $path, string $name): array
    {
        $policies = [];
        foreach ($this->getAuthorizationRulesClasses($path) as $class) {
            $methodNames   = $this->getActions($class);
            $resourcesType = $this->getResourcesType($class);
            $policies[]    = $this->createClassPolicy($name, $class, $methodNames, $resourcesType);
        }
        $policySet    = (new PolicySet($policies, PolicyAlgorithm::firstApplicable()))->setName($name);
        $policiesData = (new PolicyDecisionPoint($policySet))->getEncodePolicySet();

        return $policiesData;
    }
699427
public function loadFile($path)
    {
        $parser = Parser::parse($path, $this);
        $this->onLoad();
        return !$parser->isErroneous();
    }
250986
protected function _mkdir($path, $name) {
		$path = $path.DIRECTORY_SEPARATOR.$name;

		if (@mkdir($path)) {
			@chmod($path, $this->options['dirMode']);
			return $path;
		}

		return false;
	}
688793
public static function bundle( $name, $path = null ) 
	{
		static::$bundles[$name] = $path;
		static::$namespaces[$name] = $path.CCDIR_CLASS;
	}
1010655
public static function class_loader($name) {
        if (strncmp(__NAMESPACE__ . '\\', $name, self::$len) !== 0) {
            return false;
        }
        $name = substr($name, self::$len);
        $file_path = __DIR__ . '/' . str_replace('\\', '/', $name) . '.php';
        if (file_exists($file_path) && is_readable($file_path)) {
            include($file_path);
            return true;
        }
        return false;
    }
1046257
public static function init($path, $name = 'log', $minimumLevel = self::DEBUG)
    {
        if($path === 'php://output')
        {
            self::$active = true;
        }
        else if(is_writable($path))
        {
            self::$active = true;
        }
        else 
        {
            self::$active = false;
        }
        
        self::$backend = null;
        self::$stream = null;
        self::$name = $name;
        self::$logFilePath = $path;
        self::$minimumLevel = $minimumLevel;
    }
903755
public static function download($path = false, $extension = false, $name = false) {

        File::download($path, $extension, $name);
    }
371287
public function loadFrom($path)
    {
        // Avoid repeat load of broken images
        $hash = sha1($path);
        if ($this->hasFailed($hash, null)) {
            return $this;
        }

        // Handle resource
        $error = self::FAILED_UNKNOWN;
        try {
            $this->setImageResource($this->getImageManager()->make($path));
            $this->markSuccess($hash, null);
            $error = null;
        } catch (NotReadableException $ex) {
            // Handle unsupported image encoding on load (will be marked as failed)
            // Unsupported exceptions are handled without being raised as exceptions
            $error = self::FAILED_INVALID;
        } finally {
            if ($error) {
                $this->markFailed($hash, null, $error);
            }
        }

        return $this;
    }
747608
protected function _mkfile($path, $name) {
		if ($this->tmp) {
			$path = $path.'/'.$name;
			$local = $this->getTempFile();
			$res = touch($local) && ftp_put($this->connect, $path, $local, FTP_ASCII);
			@unlink($local);
			return $res ? $path : false;
		}
		return false;
	}
1355041
protected function _mkdir($path, $name) {
		$path = $path.'/'.$name;
		if (ftp_mkdir($this->connect, $path) === false) {
			return false;
		} 
		
		$this->options['dirMode'] && @ftp_chmod($this->connect, $this->options['dirMode'], $path);
		return $path;
	}
45688
protected function loadGroup(string $name): void
    {
        $file = $this->container->get('config_dir').'/'.$name.'.php';
        $data = \is_file($file) ? include($file) : [];
        $this->container['config_'.$name] = $data;
    }
873314
public function load($path)
    {
        if (!file_exists($path)) {
            throw new FileNotFoundException(sprintf('File "%s" does not exist or is unreadable', $path));
        }

        ob_start();
        include $path;
        $contents = ob_get_clean();

        return $contents;
    }
1142196
public function load($name)
    {
        if (!array_key_exists($name, $this->cached)) {
            foreach (array_reverse($this->paths) as $path) {
                foreach ($this->parsers as $ext => $parser) {
                    $file = "$path/$name.$ext";
                    if (is_file($file)) {
                        $this->cached[$name] = new $parser($file);

                        break 2;
                    }
                }
            }
        }

        if (!isset($this->cached[$name])) {
            $this->cached[$name] = new NativeArray;
        }

        return $this->cached[$name];
    }