Get the filesystem with the corresponding prefix.

@param string $prefix

@return FilesystemInterface
@throws FilesystemNotFoundException
497973
public function getFilesystem(string $prefix)
    {
        if (!isset($this->filesystems[$prefix])) {
            if (isset($this->lazy[$prefix])) {
                return $this->filesystems[$prefix] = new Filesystem($this->lazy[$prefix]);
            }

            throw new FilesystemNotFoundException('No filesystem mounted with prefix ' . $prefix);
        }

        return $this->filesystems[$prefix];
    }
1314945
public function getFilesIterator($prefix = '', $marker = '')
	{
		return $this->s3Client->getIterator('ListObjects', array(
			'Bucket' => $this->getBucket(),
			'Prefix' => $prefix,
			'Marker' => $marker
		));
	}
143459
public function getGridFS($prefix = 'fs')
    {
        if ($this->eventManager->hasListeners(Events::preGetGridFS)) {
            $this->eventManager->dispatchEvent(Events::preGetGridFS, new EventArgs($this, $prefix));
        }

        $gridfs = $this->doGetGridFS($prefix);

        if ($this->eventManager->hasListeners(Events::postGetGridFS)) {
            $this->eventManager->dispatchEvent(Events::postGetGridFS, new EventArgs($this, $gridfs));
        }

        return $gridfs;
    }
896126
public function prefix($prefix)
    {
        $this->uri = trim($prefix, '/') .'/' .trim($this->uri, '/');

        return $this;
    }
1165928
public function mountFilesystem(string $prefix, $filesystem)
    {
        if (\is_array($filesystem)) {
            $this->lazy[$prefix] = $filesystem;
        } else {
            $this->filesystems[$prefix] = $filesystem;
        }

        return $this;
    }
213122
public function getCacheDir()
    {
        $fileSystem = new Filesystem();
        $path = 'var/cache/assets/'.$this->name.'/';
        
        if (!$fileSystem->exists($path)) {
            $fileSystem->mkdir($path);
        }
        
        return $path;
    }
965074
private function getResourceFromParameter($prefix = '--unique-prefix')
    {
        $resource = null;
        $hasParameter = false;

        $val = $this->getParameterValue($prefix);
        if ($val) {
            $hasParameter = true;
            $resource = $this->getResource($val);
            if (!$resource->exists()) {
                $resource = null;
            }
        }

        return $hasParameter ? $resource : false;
    }
667225
public function withNamePrefixedBy(string $prefix) : Index
    {
        if ($prefix === '') {
            return $this;
        }

        return new Index(
                $prefix . $this->name,
                $this->isUnique,
                $this->columnNames
        );
    }
672958
public function getSubBlocks($prefix): IPBlockIterator
    {
        $prefix = ltrim($prefix, '/');
        $this->checkPrefix($prefix);

        if ($prefix <= $this->prefix) {
            throw new \InvalidArgumentException("Prefix must be smaller than {$this->prefix} ($prefix given)");
        }

        $first_block = new static($this->first_ip, $prefix);
        $number_of_blocks = gmp_pow(2, $prefix - $this->prefix);

        return new IPBlockIterator($first_block, $number_of_blocks);
    }
369155
public function prefix($prefix)
    {
        $uri = rtrim($prefix, '/').'/'.ltrim($this->uri, '/');

        $this->uri = trim($uri, '/');

        return $this;
    }
1069085
public function read($path)
    {
        [$prefix, $path] = $this->getPrefixAndPath($path);

        return $this->getFilesystem($prefix)->read($path);
    }
20609
protected function getBuilder($prefix, $path = false)
    {
        return (
            $path
            ? $this->getPathBuilder($prefix)
            : $this->getPropertyBuilder($prefix)
        );
    }
52248
public function getTaxonomyForPrefix( $prefix )
	{
		if ( ! $prefix ) return null;

		$taxonomies = array_filter(
			$this->getImportedSchemas(),
			function( $taxonomy ) use( $prefix ) { return $taxonomy->getPrefix() == $prefix; }
		);
		if ( ! $taxonomies ) return null;
		return reset( $taxonomies );
	}
31254
protected function getPropertyBuilder($prefix)
    {
        $build = function ($value, $key, $sub = null) use (&$prefix, &$build) {
            $sub = ($sub ? $sub : $prefix);

            if (!is_numeric($key)) {
                $sub .= static::SEP_MAJOR . $this->fixString($key);
            }

            if (is_array($value)) {
                return array_map(
                    $build,
                    $value,
                    array_keys($value),
                    array_fill(0, count($value), $sub)
                );
            }

            $sep = (
                $prefix === $sub
                ? static::SEP_MINOR
                : str_repeat(static::SEP_MAJOR, static::SEP_MULTI)
            );

            return $sub . $sep . $this->fixString($value);
        };

        return $build;
    }
437085
public function prefixDirectoryStack($path)
    {
        if ($this->withinWorkingDirectory())
        {
            return rtrim($this->getWorkingDirectory().'/'.ltrim($path, '/'), '/');
        }

        return $this->prefixPublicPath($path);
    }
69763
public function getFileCollection($prefix = 'fs', $refresh = false)
    {
        if ($refresh || !array_key_exists($prefix, $this->_fileCollections)) {
            $this->_fileCollections[$prefix] = $this->selectFileCollection($prefix);
        }

        return $this->_fileCollections[$prefix];
    }
747495
public static function get( $path, $prefix = '', $suffix = '' ) {
	
		if ( substr( $path, 0, 1 ) == '/' || substr( $path, 0, 3 ) == "::/" ) {
			return $path.$suffix;
		} 

		if ( strpos( $path, '::' ) === false ) {
			return \APPPATH.$prefix.$path.$suffix;
		}
		
		$name = explode( '::', $path );
		
		// do we have a namepsace
		if ( array_key_exists( $name[0], \CCFinder::$bundles ) ) 
		{
			return \CCFinder::$bundles[$name[0]].$prefix.$name[1].$suffix;
		}
		
		return false;
	}