Load the service provider manifest file.

@throws \Illuminate\Contracts\Filesystem\FileNotFoundException

@return array|null
760195
public function loadManifest()
    {
        if ($this->files->exists($this->manifestPath)) {
            $manifest = $this->files->getRequire($this->manifestPath);

            if ($manifest) {
                return array_merge(['when' => []], $manifest);
            }
        }
    }
267852
private function load()
    {
        if (! isset($this->runtime_file_content)) {
            $this->runtime_file_content = json_decode(@file_get_contents($this->getFilePath()), true);
        }

        return $this->runtime_file_content;
    }
1083517
private function getContent()
    {
        if (null === $this->manifestData) {
            if (!file_exists($this->manifestPath)) {
                throw new \RuntimeException(sprintf('Asset manifest file "%s" does not exist.', $this->manifestPath));
            }

            $this->manifestData = json_decode(file_get_contents($this->manifestPath), true);
            if (0 < json_last_error()) {
                throw new \RuntimeException(sprintf('Error parsing JSON from asset manifest file "%s" - %s', $this->manifestPath, json_last_error_msg()));
            }
        }

        return $this->manifestData;
    }
477569
public function load()
    {
        $this->ensureFileIsReadable();

        $filePath = $this->filePath;
        $lines = $this->readLinesFromFile($filePath);
        foreach ($lines as $line_number => $line) {
            if (!$this->isComment($line) && $this->looksLikeSetter($line)) {
                $this->setEnvironmentVariable($line, $line_number);
            }
        }

        return $lines;
    }
335795
public function load()
    {
        if (!file_exists($this->file)) {
            return []; // File doesn't exist yet.
        }
        $data = file_get_contents($this->file);
        if (strlen($data) === 0) {
            return [];
        }
        if ($this->isEncrypted()) {
            $data = Crypto::decryptWithPassword($data, $this->key, true);
        }
        return json_decode($data, true);
    }
1035876
public function registerConfiguredProviders()
	{
		$manifestPath = $this->getCachedServicesPath();

		(new ProviderRepository($this, new Filesystem, $manifestPath))
					->load($this->config['app.providers']);
	}
796362
public function load() {
		if( !$this->path ) {
			throw new \Exception('Unable to load AppConfig from undefined path');
		}
		$this->data	= json_decode(file_get_contents($this->path), true);
	}
1110485
protected function bootstrapApp()
    {
        $namespace = $this->getUserNamespace();

        // Load service provider
        $serviceProvider = $namespace.'\\'.$namespace.'ServiceProvider';
        $hasServiceProvider = class_exists($serviceProvider);
        if ($hasServiceProvider) {
            $plugins = (array) $this->config->get('plugins.loaded');
            $plugins[] = $serviceProvider;
            $this->config->set('plugins.loaded', $plugins);
        }

        return $hasServiceProvider;
    }
927178
public function load()
    {
        $returnValue = array();

    	//load it using the SimpleXml library
        $xml = false;
    	switch($this->sourceType){
    	    
    		case self::SOURCE_FILE:
    		    $xml = simplexml_load_file($this->source);
    		break;
    		
    		case self::SOURCE_URL:
    			$xmlContent = tao_helpers_Request::load($this->source, true);
    			$xml = simplexml_load_string($xmlContent);
    		break;
    		
    		case self::SOURCE_STRING:
    			$xml = simplexml_load_string($this->source);
    		break;
    	}
    	
    	if ($xml !== false) {
    		
    		//get the QTI Item's resources from the imsmanifest.xml
    		$returnValue = ManifestParserFactory::getResourcesFromManifest($xml);
    		
    		if (!$this->valid) {
    			$this->valid = true;
    			libxml_clear_errors();
    		}
    	}
    	else if (!$this->valid) {
    		$this->addErrors(libxml_get_errors());
    		libxml_clear_errors();
    	}
        
        return (array) $returnValue;
    }
32307
protected function getFile()
    {
        $path = $this->directory.'/'.self::MANIFEST_FILENAME;
        $file = $this->pathHelper->getPublicPath($path, true);
        return $file;
    }
1210323
protected static function retrieveServiceConfigurationFiles()
    {
        $virtualFile = self::$registry->getPath()->get('configuration').'.service.json';
        $caching     = self::$registry->getParameter('doozr.kernel.caching');
        $files       = null;
        $stale       = false;

        // Try to load service configurations from cache!
        if (true === $caching) {
            try {
                $files = self::$registry->getCache()->getItem($virtualFile)->get();

            } catch (Doozr_Cache_Service_Exception $exception) {
                // Intentionally left empty
            }
        }

        // Could be loaded from cache? otherwise lookup here (PERFORMANCE:IMPACT:HIGH:FILESYSTEM)
        if (null === $files) {
            $stale   = true;
            $pattern = self::$registry->getPath()->get('service').
                       '*'.DIRECTORY_SEPARATOR.'*'.DIRECTORY_SEPARATOR.'.config.json';
            $files   = glob($pattern, GLOB_NOSORT);
        }

        // Cache items found for reuse later
        if (true === $stale && true === $caching) {
            $cacheItem = new CacheItem($virtualFile);
            $cacheItem->set($files);

            self::$registry->getCache()->save($cacheItem);
        }

        // Return collection of service configuration files
        return $files;
    }
22858
private function load()
    {
        if (file_exists(static::FILENAME)) {
            return MutableBag::from(Yaml::parse(file_get_contents(static::FILENAME)) ?: []);
        }

        return MutableBag::of();
    }
979478
private function loadCache()
    {
        if (!is_null($this->cache)) {
            return $this->cache;
        }

        if (file_exists($this->getCacheFile()) && !empty($this->getCacheFile())) {
            $this->cache = json_decode(file_get_contents($this->getCacheFile()), true);
            return $this->cache;
        }
        return null;
    }
642826
private function getManifest()
    {
        if (!isset($this->manifest)) {
            $context = stream_context_create(['http' => ['timeout' => $this->manifestTimeout]]);
            $manifestContents = file_get_contents($this->manifestUrl, false, $context);
            if ($manifestContents === false) {
                throw new \RuntimeException(sprintf('Failed to download manifest: %s', $this->manifestUrl));
            }

            $this->manifest = (array) json_decode($manifestContents, true);
            if (json_last_error() !== JSON_ERROR_NONE) {
                throw new JsonParsingException(
                    'Error parsing manifest file'
                    . (function_exists('json_last_error_msg') ? ': ' . json_last_error_msg() : '')
                );
            }
        }

        return $this->manifest;
    }
1104561
protected function readManifestFile()
    {
        if (file_exists($this->manifest)) {
            return json_decode(
                file_get_contents($this->manifest),
                true
            );
        }

        return false;
    }
1233096
private function load()
    {
        $decoder = new JsonDecoder();
        $decoder->setObjectDecoding(JsonDecoder::ASSOC_ARRAY);

        $this->json = file_exists($this->path)
            ? $decoder->decodeFile($this->path)
            : array();

        if (!isset($this->json['keysByTypeName'])) {
            $this->json['keysByTypeName'] = array();
            $this->json['typesByKey'] = array();
            $this->json['bindingsByKey'] = array();
            $this->json['nextKey'] = 0;
        }
    }
351544
public function load()
    {
        if (!$this->esprima) {

            $this->esprima = $this->loadFile(
                $this->locator->locate($this->file)
            );
        }

        return $this->esprima;
    }