Push a VirtFsLoader onto the stack of autoloaders for the virtual filesystem.

@param \NoccyLabs\VirtFs\VirtFsLoader The loader to register
@return \NoccyLabs\VirtFs\VirtFs
516405
public function pushLoader(VirtFsLoader $loader)
    {
        if (!in_array($loader,$this->loaders)) {
            $this->loaders[] = $loader;
        }
        return $this;
    }
1151486
public function setVolumeDriver(string $volumeDriver)
    {
        $this->volumeDriver = $volumeDriver;

        $this->hostConfig = array_merge($this->hostConfig, ['VolumeDriver' => $volumeDriver]);

        return $this;
    }
1211047
protected function getFilesystem()
	{
		if (!isset($this->filesystem)) {
			$this->filesystem = new Filesystem($this->getAdapter());
		}
		return $this->filesystem;
	}
785841
public function createLoader(array $autoloads)
    {
        $loader = new ClassLoader();

        if (isset($autoloads['psr-0'])) {
            foreach ($autoloads['psr-0'] as $namespace => $path) {
                $loader->add($namespace, $path);
            }
        }

        if (isset($autoloads['psr-4'])) {
            foreach ($autoloads['psr-4'] as $namespace => $path) {
                $loader->addPsr4($namespace, $path);
            }
        }

        return $loader;
    }
1122318
protected function collectionLoader()
    {
        if ($this->collectionLoader === null) {
            $this->collectionLoader = $this->createCollectionLoader();
        }

        return $this->collectionLoader;
    }
931995
public static function createContainer()
    {
        $resolver = new ReferenceResolver();
        
        $builder = new ContainerBuilder($resolver, [self::$appDir]);

        foreach (self::$loaders as $loader) {
            $builder->addLoader($loader);
        }
        $builder->setApplicationRootDirectory(self::$appDir);

        $builder->addConfigFiles(self::$configFiles);

        return $builder->createContainer();
    }
1304959
protected function buildContainer()
    {
        $container = $this->getContainerBuilder();
        $container->addObjectResource($this);
        $this->prepareContainer($container);
        if (null !== $cont = $this->registerContainerConfiguration($this->getContainerLoader($container))) {
            $container->merge($cont);
        }
        return $container;
    }
1367595
private function buildLoader($loader)
    {
        if ($loader instanceof TemplateLoaderInterface || is_callable($loader)) {
            return $loader;
        }

        if (is_string($loader) && is_subclass_of($loader, TemplateLoaderInterface::class, true)) {
            return function () use ($loader) {
                return new $loader();
            };
        }
    }
387307
public function load(): self
    {
        $this->loader = new Loader($this->files, true);
        $this->loader->load();

        return $this;
    }
424040
public function register(FixtureLoader $loader)
    {
        $value = new Pair($loader->getName(), $loader);
        $this->loaders->add($value);
        return $this;
    }
226548
public static function composer()
    {
        $loaders = spl_autoload_functions();

        foreach ($loaders as $key => $loader) {
            if (is_array($loader) && ($loader[0] instanceof ClassLoader)) {
                return $loader;
            }
        }
    }
442230
public function metadataLoader()
    {
        if (!isset($this->metadataLoader)) {
            throw new RuntimeException(sprintf(
                'Metadata Loader is not defined for [%s]',
                get_class($this)
            ));
        }

        return $this->metadataLoader;
    }
218743
protected function registerLoader()
    {
        $this->app->singleton('translation.loader', function ($app) {
            $paths = [
                base_path('vendor/caouecs/laravel-lang/src/'),
            ];

            if ($this->inLumen) {
                $this->app['path.lang'] = base_path('vendor/laravel/lumen-framework/resources/lang');
                array_push($paths, base_path('resources/lang/'));
            }

            $loader = new FileLoader($app['files'], $app['path.lang'], $paths);

            if (\is_callable([$loader, 'addJsonPath'])) {
                $loader->addJsonPath(base_path('vendor/caouecs/laravel-lang/json/'));
            }

            return $loader;
        });
    }
476670
public function create($storage = null)
    {
        $storage = $storage ?: $this->getStorageDisk();

        return new FileHandler(
            $this->makeStorage($storage),
            $this->makeProcessor()
        );
    }
90342
public static function storageInstance() {
		if (self::$instance) {
			return self::$instance;
		}

		if (!isset(self::$registry[self::driver()])) {
			throw new StorageException("Invalid driver '".self::driver()."'");
		}

		$class = self::$registry[self::driver()];
		self::$instance = new $class();

		return self::$instance;
	}
469021
public function getLoader()
    {
        if ($this->loader === null) {
            $this->loader = new Loader($this->getCompileDir());
        }

        return $this->loader;
    }
133418
public function fs()
    {
        if (null === $this->fs)
            $this->fs = new Filesystem($this->getFilesystemPath(), $this->adapter);
        return $this->fs;
    }