{@inheritdoc}

@see \Zend\I18n\Translator\Loader\Gettext::load()
541902
public function load($locale, $filename)
    {
        $textDomain = parent::load($locale, $filename);

        $localeInfo = Language::getById($locale);
        if ($localeInfo !== null) {
            $this->fixPlurals($filename, $textDomain, $localeInfo);
        }

        return $textDomain;
    }
441267
public function load() {
        if ($this->_loaded) return;
        $factory = HTMLPurifier_LanguageFactory::instance();
        $factory->loadLanguage($this->code);
        foreach ($factory->keys as $key) {
            $this->$key = $factory->cache[$this->code][$key];
        }
        $this->_loaded = true;
    }
1277100
public function load()
    {
        if (! file_exists($file = $this->getFileName())) {
            return collect();
        }

        return collect(json_decode(file_get_contents($file), true));
    }
1104546
public function load($file, $format = 'ini', $loader = 'file')
    {
        if ($format === 'php') {
            $loader = 'php';
        }

        try {
            $string = $this->getLoader($loader)->load($file);

            $string = $this->getFormat($format)->parse($string);
        } catch (\Throwable $e) {
            throw new \ErrorException(
                $e->getMessage(),
                $e->getCode(),
                E_ERROR,
                $file,
                $e->getLine(),
                $e
            );
        }

        $this->addStrings($string);

        return $this;
    }
815625
public function load() {
        $ext = mb_strtolower(pathinfo($this->_path, PATHINFO_EXTENSION));

        switch ($ext) {
            case 'php':
                return include $this->_path;
            break;
            case 'json':
                return json_decode(file_get_contents($this->_path), true);
            break;
            case 'ini':
                return parse_ini_file($this->_path, true);
            break;
            case 'txt':
                return file($this->_path, FILE_IGNORE_NEW_LINES);
            break;
        }

        throw new UnsupportedTypeException(sprintf('Unsupported FileLoader file type %s', $ext));
    }
855085
protected static function loadTranslation($string, $text_domain)
    {
        /**
         * Locale file path
         *
         * @var string $file
         */
        $file = static::$dir . '/' . static::$locale . '/' . $text_domain . '.php';

        /**
         * Check if we have already loaded this file
         */
        if (array_key_exists($file, static::$loaded)) {

            /**
             * Save missing string if configured to
             */
            if (static::$autoGenerate && (!isset(static::$loaded[$file][$string]))) {
                return static::addTranslation($file, $string);
            }

            /** return processed string */
            return isset(static::$loaded[$file][$string]) && !empty(static::$loaded[$file][$string])
                ? self::$loaded[$file][$string] : $string;
        }

        /**
         * Check if the file exists
         */
        if (!file_exists($file)) {

            /**
             * Create file if not in configured to
             */
            if (static::$autoGenerate) {
                static::saveTranslationFile($file, [$string => '']);
            }

            return $string;
        }
        /** @noinspection PhpIncludeInspection */
        static::$loaded[$file] = (array)require $file;

        /**
         * Save missing string if not in production
         */
        if (static::$autoGenerate && (!isset(static::$loaded[$file][$string]))) {
            return static::addTranslation($file, $string);
        }

        /** return processed string */
        return isset(static::$loaded[$file][$string]) && !empty(static::$loaded[$file][$string])
            ? static::$loaded[$file][$string] : $string;
    }
303246
private function _loadLanguageItems()
    {
        $this->_languageItems = LanguageSource::find()
            ->joinWith(['languageTranslate' => function ($query) {
                $query->where(['language' => $this->_languageId]);
            },
            ])
            ->where(['category' => Scanner::CATEGORY_JAVASCRIPT])
            ->all();
    }
674387
public function loadLanguage()
    {
        $package = $this->getIdentifier()->package;
        $domain  = $this->getIdentifier()->domain;

        if($domain) {
            $url = 'com://'.$domain.'/'.$package;
        } else {
            $url = 'com:'.$package;
        }

        $this->getObject('translator')->load($url);
    }
694411
public function load($source)
    {
        if (isset($this->_messages[$source])) {
            return $this->_messages[$source];
        } else {
            $filename_cordillera = CORDILLERA_DIR.'languages'.DS.$this->language.DS.$source.'.php';
            $filename_app = CORDILLERA_APP_DIR.'languages'.DS.$this->language.DS.$source.'.php';

            $this->_messages[$source] = is_file($filename_app) ?
                require_once $filename_app : (is_file($filename_cordillera) ? require_once $filename_cordillera : []);
        }

        return $this->_messages[$source];
    }
1336542
private function load()
    {
        $this->locales->loadFromArray($this->getConfig('locales'));
        $this->setSupportedLocales($this->getConfig('supported-locales'));
        $this->setDefaultLocale();
    }
256714
public function load()
    {
        $this->raw = $this->exists() ? (string) file_get_contents($this->filename) : '';
        $this->content = null;

        return $this->raw;
    }
507358
public function load()
    {
        if ($this->_cache instanceof \Zend_Cache_Core) {
            $cache = $this->_cache;
            if (! ($cache->test($this->_cacheid) && $cache->test($this->_cacheid . 'trans'))) {
                // cache miss
                $this->build();
            } else {
                // cache hit
                $this->_acl = $cache->load($this->_cacheid);
                $this->_roleTranslations = $cache->load($this->_cacheid . 'trans');
            }
        } else {
            $this->build();
        }
    }
520425
public function loadInfo($data)
    {
        if ($this->isJson($data)) {
            $data = \Zend_Json_Decoder::decode($data);
        } elseif (is_null($data)) {
            $data = [];
        }

        $this->addData($data);

        return $this;
    }
768192
public function loadTranslations($translations)
    {
        if (is_object($translations) && $translations instanceof Translations) {
            $translations = PhpArray::generate($translations, ['includeHeaders' => false]);
        } elseif (is_string($translations) && is_file($translations)) {
            $translations = include $translations;
        } elseif (!is_array($translations)) {
            throw new \InvalidArgumentException(
                'Invalid Translator: only arrays, files or instance of Translations are allowed'
            );
        }

        $this->addTranslations($translations);

        return $this;
    }
697210
public function load($data, $format = 'php')
    {
        if (!$data) {
            return $this;
        }

        if (\is_string($data) && \in_array($format, static::$formats, true)) {
            switch ($format) {
                case static::FORMAT_YML:
                    $this->loadYaml($data);
                    break;

                case static::FORMAT_JSON:
                    $this->loadJson($data);
                    break;

                case static::FORMAT_INI:
                    $this->loadIni($data);
                    break;

                case static::FORMAT_PHP:
                default:
                    $this->loadArray($data);
                    break;
            }

        } elseif (\is_array($data) || \is_object($data)) {
            $this->bindData($this->data, $data);
        }

        return $this;
    }
1014575
private function load($id = null)
    {

        $this->initialize();
        $this->id = $id;
        return $this->getDataConnector()->loadContext($this);

    }
1108889
protected function load($source)
    {
        $reader = new FileReader($source);

        $dictionary = new MimeTypeDictionary($reader);

        foreach ($dictionary as $entry) {
            $this->dict += array_fill_keys(
                $entry->fileExtensions,
                $entry->mimeType
            );
        }
    }