Get the storage with the given name

@param string $name

@return Storage
352557
protected function getStorage($name)
    {
        if (!array_key_exists($name, $this->storages))
        {
            throw new StorageDoesNotExistException('Invalid storage name: '.$name);
        }
        
        return $this->storages[$name];
    }
902006
public function &__get($name)
    {
      $retval = null;	

      if('name' === $name){
      	 return $this->name;
      }elseif('dump' === $name){
      	 $retval = $this->_dump();
      	 return $retval;
      }elseif (isset($this->data[$name])){
           $retval = $this->data[$name];
           return $retval;
	  }

        return $retval;
    }
1363536
public function createStorage($containerName)
    {
        $storageProvider = $this->createStorageProvider();

        return new Storage(
            $storageProvider->createFilesystem($containerName),
            $storageProvider->getBaseUrl($containerName)
        );
    }
1335461
public function resolveFile($name)
    {
        if($this->getStorageFacility() == null)
            return null;

        return $this->getStorageFacility()->resolveFile($this->getStorageFacilityParams(), $name);
    }
949972
public function getFile(string $name)
    {
        $contentArea = $this->content->getFile($name);

        if ($contentArea) {
            return $contentArea->file;
        }

        return null;
    }
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;
    }
1132051
public function getStorage($clone = false) : Storage
    {
        if ($this->storage === null) {
            $this->storage = new Storage($this->getCache());
        }
        return $clone ? clone $this->storage : $this->storage;
    }
1176093
public function getStore( string $name = null ): CacheStoreInterface
	{
		if( is_null($name) )
		{
			$name = "default";
		}

		if( isset($this->store[$name]) || $this->loadStore($name) )
		{
			return $this->store[$name];
		}

		throw new NotFoundException("The '{$name}' cache store config not found");
	}
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);
    }
862933
public function getDependencyStorage($name)
    {
        $dependencyStorage = $this->dependencies->getStorageItem($name, $this->getOption('dependencies_storage'));

        $event = new DependencyStorageEvent($dependencyStorage);
        $this->trigger($event);

        return $event->getDependencyStorage();
    }
65921
private static function createFromConfig($name): Storage\StorageInterface
    {
        $config = &self::$config['storage'][$name];
        $driver = &$config['driver'];
        $config = &$config['config'];

        return new self::$driver[$driver]($config);
    }
1045175
public function withStorage($name)
    {
        $self          = clone($this);
        $self->segment = $this->session->getSegment($name);

        return $self;
    }
600801
public function getMetadata(string $name)
    {
        return $this->metadata->where(function (ContentMetadata $metadata) use ($name) {
            return $metadata->name === $name;
        })->first();
    }
412463
protected function get($name)
    {
        return isset($this->stores[$name]) ? $this->stores[$name] : $this->resolve($name);
    }
728630
public function get($name)
    {
        $this->_validate();
        if (array_key_exists($name, $_SESSION[$this->publicStorage]['store'][$this->_namespaceName])) {
            return $_SESSION[$this->publicStorage]['store'][$this->_namespaceName][$name];
        }
        return false;
    }
1062349
public static function getStorage($name=StorageInterface::class){
        if($name=='default')$name=StorageInterface::class;
        if(static::$storageArr[$name]){
            return static::$storageArr[$name];
        }
        $storage=Ioc::get($name);
        if(!$storage){
            throw new SystemException($name."文件存储不存在,你写个类可以继承自".StorageInterface::class);
        }else
        if($storage instanceof StorageInterface){
            static::$storageArr[$name]=new Storage($storage);
            return static::$storageArr[$name];
        }else{
            throw new SystemException($name."文件存储需要继承".StorageInterface::class);
        }
    }
941288
protected function getContainer($name)
    {
        if (!isset($this->containers[$name])) {
            $this->createContainer($name);
        }

        return $this->containers[$name];
    }