{@inheritDoc}
@see \Symfony\Component\Translation\Loader\LoaderInterface::load()
1520
public function load($resource, $locale, $domain = 'messages') {
		$repo = $this->service->getResourceRepository();
		if (!$repo->contains($resource)) {
			throw new NotFoundResourceException(sprintf('File "%s" not found.', $resource));
		}

		// find file in puli repo
		$file = $repo->get($resource);
		$json = $file->getBody();
		$data = Json::decode($json);
		$messages = [];

		// flatten plural strings
		foreach ($data as $key => $value) {
			if (is_array($value)) {
				$vals = [];
				foreach ($value as $k => $v) {
					$vals[] = sprintf('%s: %s', $k, $v);
				}
				$val = implode('|', $vals);
			} else {
				$val = $value;
			}

			$messages[$key] = str_replace(['{{', '}}'], '%', $val);
		}

		// put them into message catalog
		$catalogue = new MessageCatalogue($locale);
		$catalogue->add($messages, $domain);

		return $catalogue;
	}
21974
public function registerContainerConfiguration(\Symfony\Component\Config\Loader\LoaderInterface $loader)
    {
        $loader->load(__DIR__.self::CONFIG_PATH.self::SERVICES_FILE);
    }
399234
public function load($resource, $type = null) 
    {
        $path = $this->locator->locate($resource);
        
        if (!stream_is_local($path)) {
            throw new \InvalidArgumentException(sprintf('This is not a local file "%s".', $path));
        }

        if (!file_exists($path)) {
            throw new \InvalidArgumentException(sprintf('File "%s" not found.', $path));
        }

        $returnArray = include $path;
        
        if(false === is_array($returnArray)) {
            throw ConfigException::configNotArray($path);
        }
        
        $this->loaded[$resource] = $path;
        
        return $returnArray;
    }
1215912
private function load()
    {
        // Get English version
        $english = $this->getTranslations(__DIR__, 'en');
        $languages = $this->getLanguages();

        $this->compareTranslations($english, $languages);
    }
851087
public function load(ConfigurationInterface $configuration)
    {

        // initialize the default loader and load the DI configuration for the this library
        $defaultLoader = new XmlFileLoader($this->getContainer(), new FileLocator($this->getVendorDir()));

        // load the DI configuration for all the extension libraries
        foreach ($configuration->getExtensionLibraries() as $library) {
            if (file_exists($diConfiguration = sprintf('%s/%s/symfony/Resources/config/services.xml', $this->getVendorDir(), $library))) {
                $defaultLoader->load($diConfiguration);
            } else {
                throw new \Exception(
                    sprintf(
                        'Can\'t load DI configuration for library "%s"',
                        $diConfiguration
                    )
                );
            }
        }

        // register autoloaders for additional vendor directories
        $customLoader = new XmlFileLoader($this->getContainer(), new FileLocator());
        foreach ($configuration->getAdditionalVendorDirs() as $additionalVendorDir) {
            // load the vendor directory's auto loader
            if (file_exists($autoLoader = $additionalVendorDir->getVendorDir() . '/autoload.php')) {
                require $autoLoader;
            } else {
                throw new \Exception(
                    sprintf(
                        'Can\'t find autoloader in configured additional vendor directory "%s"',
                        $additionalVendorDir->getVendorDir()
                    )
                );
            }

            // try to load the DI configuration for the configured extension libraries
            foreach ($additionalVendorDir->getLibraries() as $library) {
                // prepare the DI configuration filename
                $diConfiguration = realpath(sprintf('%s/%s/symfony/Resources/config/services.xml', $additionalVendorDir->getVendorDir(), $library));
                // try to load the filename
                if (file_exists($diConfiguration)) {
                    $customLoader->load($diConfiguration);
                } else {
                    throw new \Exception(
                        sprintf(
                            'Can\'t load DI configuration for library "%s"',
                            $diConfiguration
                        )
                    );
                }
            }
        }
    }
1001834
public static function load($source)
    {
        self::$variables = is_array($source) ? $source : require $source;
        self::$isLoaded = true;

        self::checkRequiredVariables();
    }
31950
public function load(array $files = array())
    {
        $loader = new YamlLoader(new FileLocator, new YamlParser);

        foreach ($files as $file) {
            $configValues = $loader->load($file);

            $configValues = $this->loadImports($loader, $file, $configValues);

            $this->params = array_replace_recursive($this->params, $configValues);
        }
    }
1073131
public function load()
    {
        $contents = $this->repository->get($this->key);

        if (! is_null($contents)) {
            $this->setFromStorage($contents);
        }
    }
948036
public function load($file)
    {
        $loader = new PhpConfig();
        $templates = $loader->read($file);
        $this->add($templates);
    }
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;
                }
            }
        }
    }
200465
public function load()
    {
        $this->loadChildClasses();

        list($constructorResolvedOptions, $extraResolvedOptions) = $this->resolveOptions();
        $instance = $this->reflected->newInstanceArgs($constructorResolvedOptions);

        $this->loadExtraOptions($extraResolvedOptions, $instance);

        return $instance;
    }
362680
public function load($provider, $options = null)
    {
        if (!is_object($provider)) {
            $provider = $this->getShared($provider);
        }
        $names = $provider->getNames();
        if (isset($options['aliases'])) {
            $services = $this->createServiceAliases($names, $options['aliases']);
            unset($options['aliases']);
        } else {
            $services = $names;
        }
        return $this->autoload($services, $provider, $options);
    }
983338
protected function getLoader(): LoaderInterface
    {
        if (! $this->loader instanceof LoaderInterface) {
            $this->loader = new CacheLoader(sprintf(
                '%s/%s.php',
                rtrim($this->getCacheLocation(), '/'),
                $this->getCacheFilename()
            ));
        }

        return $this->loader;
    }
481633
public function load($template)
    {
        $template = $this->findFirstExistingTemplate($template);
        if (!isset($this->loadedTemplates[ $template ])) {
            $class = $this->getTemplateClassName($template);

            $this->loadedTemplates[ $template ] = new $class($this);
            if (!$this->loadedTemplates[ $template ] instanceof Template) {
                throw new TemplatingException("The compiled class for {$template} is invalid");
            }
        }

        return $this->loadedTemplates[ $template ];
    }
1043564
protected function determineLoaderFromClass($source): LoaderInterface
    {
        foreach ($this->loaders as $key => $loader) {
            if (class_exists($key) && is_a($source, $key)) {
                return $loader;
            }
        }

        $desc = get_class($source) . ' ' . gettype($source);
        throw new NoLoaderException("Don't know how to load configuration from $desc");
    }
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;
    }
1155832
public function load()
    {
        $contents = $this->client->get($this->key);

        if ($contents !== null) {
            $this->setFromStorage($contents);
        }
    }