Load the messages for the given locale.

@param  string  $locale
@param  string  $group
@param  string  $namespace
@return array
422169
public function load($locale, $group, $namespace = null)
	{
		if (is_null($namespace) || $namespace == '*')
		{
			return $this->loadData($locale, $group);
		}

		return $this->loadNamespaced($locale, $group, $namespace);
	}
959723
protected function loadPath($path, $locale, $group)
    {
        $result = [];
        foreach ($this->paths as $path) {
            $result = array_merge($result, parent::loadPath($path, $locale, $group));
        }

        return $result;
    }
152591
private function getNamespaces(string $locale): array
    {
        $result = $this->hasLocale($locale) === true ? array_keys($this->getBundles()[$locale]) : [];

        return $result;
    }
235231
public function load($locale)
    {
        if ($this->files->exists($full = $this->path."/".$locale.".lang")) {
            return $this->loadFileData($this->files->get($full));
        }
        return [];
    }
191599
public function flush($locale, $group, $namespace)
    {
        $key = $this->getKey($locale, $group, $namespace);
        $this->store->tags([$key])->flush();
    }
1269507
protected function load($group, $namespace, $collection)
    {
        // Is it already loaded? If so, just return it.
        if (isset($this->items[$collection])) return $this->items[$collection];

        $items = $this->loader->load($this->mode, $group, $namespace);

        return $this->items[$collection] = $items;
    }
1278541
protected function getLine($namespace, $group, $locale, $item, array $replace)
    {
        $this->load($namespace, $group, $locale);

        $line = Arr::get($this->loaded[$namespace][$group][$locale], $item);

        if (is_string($line)) {
            return $this->makeReplacements($line, $replace);
        } elseif (is_array($line) && count($line) > 0) {
            foreach ($line as $key => $value) {
                $line[$key] = $this->makeReplacements($value, $replace);
            }

            return $line;
        }
    }
227783
protected function getMessages(string $locale = "en"):array
    {
        $path = __DIR__ . "/../Messages/" . $locale . "/messages.json";

        if (file_exists($path)) {
            $jsonMessages = file_get_contents($path);

            return json_decode($jsonMessages, true);
        }

        return [];
    }
773466
protected function loadNamespaceOverrides(array $lines, $locale, $group, $namespace)
    {
        $file = "{$this->path}/vendor/{$namespace}/{$locale}/{$group}.php";

        if (file_exists($file)) {
            return array_replace_recursive($lines, (require $file));
        }

        return $lines;
    }
130185
public function allToArray($locale, $group, $namespace = null)
    {
        $args = func_get_args();
        $args[] = config('app.locale');

        return $this->executeCallback(static::class, __FUNCTION__, $args, function () use ($locale, $group) {
            $array = DB::table('translations')
                    ->select(DB::raw("JSON_UNQUOTE(JSON_EXTRACT(`translation`, '$.".$locale."')) AS translation"), 'key')
                    ->where('group', $group)
                    ->pluck('translation', 'key')
                    ->all();

            return $array;
        });
    }
559332
public function load($resource, $locale, $domain = 'messages')
    {
        $catalogue = new MessageCatalogue($locale);

        foreach ($this->repository->getTranslations($locale, $domain) as $id => $translation) {
            $catalogue->set($id, $translation, $domain);
        }

        return $catalogue;
    }
918637
protected function loadLanguageFileForNamespace($namespace)
    {
        $loadedLocale = $this->request->getLocale();
        $content = $this->languageFileManager->loadTranslationFileContent($namespace, $loadedLocale);
        
        // If the received content is empty return false
        if ($content === false) {
            return false;
        }
        
        $lines = explode(PHP_EOL, $content);
        
        foreach ($lines as $line) {
            $delimiter = strpos($line, ' = ');
            if ($delimiter === false) {
                continue;
            }
            
            $pattern = substr($line, 0, $delimiter);
            $replacement = substr($line, $delimiter + 3);
            
            if (!isset($this->translatedStrings[$namespace]) || !is_array($this->translatedStrings[$namespace])) {
                $this->translatedStrings[$namespace] = array();
            }
            
            $this->translatedStrings[$namespace][$pattern] = $replacement;
        }
    }
170853
public function load($group, $namespace = null)
    {
        $items = [];

        $path = $this->getPath($namespace);

        if (is_null($path)) {
            return $items;
        }

        $file = "{$path}/{$group}.php";

        if ($this->files->exists($file)) {
            $items = $this->getRequire($file);
        }

        return $items;
    }
1114923
public function addMessages($locale, $group, array $messages, $namespace = null)
    {
        $namespace = $namespace ?: '*';

        $this->messages[$namespace][$locale][$group] = $messages;

        return $this;
    }
329352
public function findByCode($locale, $namespace, $group, $item)
    {
        return $this->model->whereLocale($locale)->whereNamespace($namespace)->whereGroup($group)->whereItem($item)->first();
    }
370782
protected function loadByGroup(/*# string */ $group)
    {
        // load super global
        if ('' !== $group && '_' === $group[0]) {
            return $this->loadGlobal($group);
        }

        // load from config
        $conf = $this->loader->load($group);

        foreach ($conf as $grp => $data) {
            $this->config->addNode($grp, $data);
        }

        return $this;
    }
390000
public function findByLangCode($locale, $code)
    {
        list($namespace, $group, $item) = $this->parseCode($code);
        return $this->model->whereLocale($locale)->whereNamespace($namespace)->whereGroup($group)->whereItem($item)->first();
    }