Returns the file system for the given name

@param string $name Key for the file system
@return \Aimeos\MW\Filesystem\Iface File system object
@throws \Aimeos\MW\Filesystem\Exception If an no configuration for that name is found
546812
public function get( $name )
	{
		$key = $this->getConfig( $name );

		if( is_string( $key ) )
		{
			if( !isset( $this->objects[$key] ) ) {
				$this->objects[$key] = new \Aimeos\MW\Filesystem\Laravel( $this->fsm->disk( $key ), $this->tempdir );
			}

			return $this->objects[$key];
		}

		return parent::get( $name );
	}
852927
public static function get( $name = '' ) {
		$name = self::sanitize( $name );
		$filename = self::get_filename( $name );

		return $filename ? @file_get_contents( $filename ) : '';
	}
457402
public function _get($name)
    {
        $name = $this->createFileName($name);
        $file = $this->cacheDir . '/' . $name;
        $data = @file_get_contents($file);
        if (!$data) {
            return false;
        }

        $data = $this->unpackData($data);
        if (false === $data) {
            @unlink($file);

            $data = null;
        }

        return $data;
    }
881829
protected function loader($name)
    {
        if (false !== \strpos('.', $name)) {
            throw new Exceptions\Invalid($name);
        }

        if (isset($this->loaders[$name])) {
            return $this->loaders[$name];
        }

        foreach ($this->extensions as $extension) {
            try {
                $path = $this->buildPath($name, $extension);
                $this->loaders[$name] = FileLoader::load($path);

                return $this->loaders[$name];
            } catch (NotFound\Path $argumentException) {
                continue;
            }
        }

        throw new NotFound\Path($this->root . $name);
    }
203829
private static function storage(string $name = 'default'): Storage\StorageInterface
    {
        $name = $name == 'default' ? (self::$config['storage']['default'] ?? self::$config['default-storage']) : $name;

        return isset(self::$storage[$name])
            ? self::$storage[$name]
            : self::$storage[$name] = self::createFromConfig($name);
    }
462304
protected function getPath($name): string
    {
        $name = str_replace_first($this->rootNamespace(), $this->moduleName().DIRECTORY_SEPARATOR.'config', $name);

        if (! $this->files->exists($path = $this->laravel['path'].DIRECTORY_SEPARATOR.$this->moduleName())) {
            throw new \Exception("Invalid path: {$path}");
        }

        return $this->laravel['path'].DIRECTORY_SEPARATOR.str_replace('\\', DIRECTORY_SEPARATOR, $name).'.php';
    }
698370
public static function getFileSystem()
    {
        if (self::$fs === null) {
            switch (Phing::getProperty('host.fstype')) {
                case 'UNIX':
                    self::$fs = new UnixFileSystem();
                    break;
                case 'WINDOWS':
                    self::$fs = new WindowsFileSystem();
                    break;
                default:
                    throw new IOException("Host uses unsupported filesystem, unable to proceed");
            }
        }

        return self::$fs;
    }
717912
public function get($name)
    {
        // create a loader by the same path and name.
        if(!isset($this->pathRegistry[$name]))
            throw new \Exedra\Exception\NotFoundException('Path with registry ['.$name.'] does not exist.');

        return $this->pathRegistry[$name];
    }
35068
public static function getOrCreateRepository($name)
    {
        $name = $name == Repository::class
            ? 'default'
            : str_replace(Repository::class . '.', '', $name);

        $repository = null;
        if (array_key_exists($name, static::$repositories)) {
            $repository = static::$repositories[$name];
        } else {
            $fullName = Repository::class . '.' . $name;
            if (!context()->exists($fullName)) {
                /**
                 * Lazy load.
                 */
                $config = config('database.' . $name);
                /**
                 * @T00D00 - this means that we're overloading every non-default repository to default one?
                 *         - this is needed when mixing different and using multiple repositories
                 *         - maybe the best thing would be to change repositories when needed (leave defaults?)
                 */
                if (!$config && $name != 'default') {
                    $config = config('database.default');
                }
                $repository = RepositoryFactory::getRepositoryByConfig($config, $name);
                context()->bind($fullName, $repository);
            }

            $repository = context()->get($fullName);
        }

        if (!$repository) {
            throw new Exception('Cannot prepare repository');
        }

        return $repository;
    }
1102296
final public static function get($name)
    {
        return isset(self::$allLoadedConfigs[$name])
            ? self::$allLoadedConfigs[$name]
            : self::$allLoadedConfigs[$name] = Arr::overwrite(static::load($name), LocalConfig::load($name));
    }
938130
function get($name,$default = null){
        $name_arr = explode(':', $name);
        if(!isset($name_arr[1])){
            $name_arr[1] = $name_arr[0];
            $name_arr[0] = 'system';
        }
        if(!isset($this->config[$name_arr[0]])){
            $this->config[$name_arr[0]] = new ConfigParser($this->config_file_path . $name_arr[0] . ".config.php");
        }
        return $this->config[$name_arr[0]]->get($name_arr[1],$default);
    }
641382
public static function get($name)
    {
        $registry = static::getRegistry();

        if (isset($registry->{$name})) {
            return $registry->{$name};
        }

        static::_buildTransport($name);

        return $registry->{$name};
    }
1220626
public function getProfile($name) {
    $dirs = $this->config['profile.dirs'];
    foreach ($dirs as $dir) {
      if (!is_dir($dir) || !is_readable($dir)) {
        continue;
      }
      $filename = $dir . DIRECTORY_SEPARATOR . $name . '.profile';
      if (is_readable($filename)) {
        $content = file_get_contents($filename);
        $json = json_decode($content);
        return $json;
      }
    }
    throw new \Exception("Profile $name not found");
  }
944019
public function get($name = null)
    {
        if ($name === null) {
            $name = $this->mainname;
        }
        if (!isset($this->dbs[$name])) {
            throw new Exceptions\StorageNotFound($name);
        }
        return $this->dbs[$name];
    }
1364551
public function getConfiguration($name)
    {
        if (!isset($this->config[$name]['configuration_class'])) {
            throw new \Exception(sprintf('Configuration for "%s" not found', $name));
        }
        $class = $this->config[$name]['configuration_class'];

        return new $class();
    }
1200181
public function get($name)
    {
        if (isset($this->files[$name])) {
            return [$this->files[$name]];
        }

        $results = [];
        foreach ($this->files as $key => $file) {
            if (strpos($key, "{$name}[") === 0) {
                $results[] = $file;
            }
        }

        return $results;
    }
1146452
protected function get( $name )
	{
		return isset( $this->disks[$name] ) ? $this->disks[$name] : $this->resolve( $name );
	}