class StreamWrapperManager in Zircon Profile 8

Provides a StreamWrapper manager.

Hierarchy

• class \Symfony\Component\DependencyInjection\ContainerAware implements ContainerAwareInterface
  • class \Drupal\Core\StreamWrapper\StreamWrapperManager implements StreamWrapperManagerInterface

See also

\Drupal\Core\StreamWrapper\StreamWrapperInterface

1 file declares its use of StreamWrapperManager

MimeTypeGuesserTest.php in core/tests/Drupal/Tests/Core/File/MimeTypeGuesserTest.php

Contains \Drupal\Tests\Core\File\MimeTypeGuesserTest.

1 string reference to 'StreamWrapperManager'

core.services.yml in core/core.services.yml

core/core.services.yml

1 service uses StreamWrapperManager

stream_wrapper_manager in core/core.services.yml

Drupal\Core\StreamWrapper\StreamWrapperManager

File

core/lib/Drupal/Core/StreamWrapper/StreamWrapperManager.php, line 17

Contains \Drupal\Core\StreamWrapper\StreamWrapperManager.

Namespace

Drupal\Core\StreamWrapper

class StreamWrapperManager extends ContainerAware implements StreamWrapperManagerInterface {

  /**
   * Contains stream wrapper info.
   *
   * An associative array where keys are scheme names and values are themselves
   * associative arrays with the keys class, type and (optionally) service_id,
   * and string values.
   *
   * @var array
   */
  protected $info = array();

  /**
   * Contains collected stream wrappers.
   *
   * Keyed by filter, each value is itself an associative array keyed by scheme.
   * Each of those values is an array representing a stream wrapper, with the
   * following keys and values:
   *   - class: stream wrapper class name
   *   - type: a bitmask corresponding to the type constants in
   *     StreamWrapperInterface
   *   - service_id: name of service
   *
   * The array on key StreamWrapperInterface::ALL contains representations of
   * all schemes and corresponding wrappers.
   *
   * @var array
   */
  protected $wrappers = array();

  /**
   * {@inheritdoc}
   */
  public function getWrappers($filter = StreamWrapperInterface::ALL) {
    if (isset($this->wrappers[$filter])) {
      return $this->wrappers[$filter];
    }
    else {
      if (isset($this->wrappers[StreamWrapperInterface::ALL])) {
        $this->wrappers[$filter] = array();
        foreach ($this->wrappers[StreamWrapperInterface::ALL] as $scheme => $info) {

          // Bit-wise filter.
          if (($info['type'] & $filter) == $filter) {
            $this->wrappers[$filter][$scheme] = $info;
          }
        }
        return $this->wrappers[$filter];
      }
      else {
        return array();
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getNames($filter = StreamWrapperInterface::ALL) {
    $names = array();
    foreach (array_keys($this
      ->getWrappers($filter)) as $scheme) {
      $names[$scheme] = $this
        ->getViaScheme($scheme)
        ->getName();
    }
    return $names;
  }

  /**
   * {@inheritdoc}
   */
  public function getDescriptions($filter = StreamWrapperInterface::ALL) {
    $descriptions = array();
    foreach (array_keys($this
      ->getWrappers($filter)) as $scheme) {
      $descriptions[$scheme] = $this
        ->getViaScheme($scheme)
        ->getDescription();
    }
    return $descriptions;
  }

  /**
   * {@inheritdoc}
   */
  public function getViaScheme($scheme) {
    return $this
      ->getWrapper($scheme, $scheme . '://');
  }

  /**
   * {@inheritdoc}
   */
  public function getViaUri($uri) {
    $scheme = file_uri_scheme($uri);
    return $this
      ->getWrapper($scheme, $uri);
  }

  /**
   * {@inheritdoc}
   */
  public function getClass($scheme) {
    if (isset($this->info[$scheme])) {
      return $this->info[$scheme]['class'];
    }
    return FALSE;
  }

  /**
   * Returns a stream wrapper instance.
   *
   * @param string $scheme
   *   The scheme of the desired stream wrapper.
   * @param string $uri
   *   The URI of the stream.
   *
   * @return \Drupal\Core\StreamWrapper\StreamWrapperInterface|bool
   *   A stream wrapper object, or false if the scheme is not available.
   */
  protected function getWrapper($scheme, $uri) {
    if (isset($this->info[$scheme]['service_id'])) {
      $instance = $this->container
        ->get($this->info[$scheme]['service_id']);
      $instance
        ->setUri($uri);
      return $instance;
    }
    return FALSE;
  }

  /**
   * Adds a stream wrapper.
   *
   * Internal use only.
   *
   * @param string $service_id
   *   The service id.
   * @param string $class
   *   The stream wrapper class.
   * @param string $scheme
   *   The scheme for which the wrapper should be registered.
   */
  public function addStreamWrapper($service_id, $class, $scheme) {
    $this->info[$scheme] = array(
      'class' => $class,
      'type' => $class::getType(),
      'service_id' => $service_id,
    );
  }

  /**
   * Registers the tagged stream wrappers.
   *
   * Internal use only.
   */
  public function register() {
    foreach ($this->info as $scheme => $info) {
      $this
        ->registerWrapper($scheme, $info['class'], $info['type']);
    }
  }

  /**
   * Unregisters the tagged stream wrappers.
   *
   * Internal use only.
   */
  public function unregister() {

    // Normally, there are definitely wrappers set for the ALL filter. However,
    // in some cases involving many container rebuilds (e.g. WebTestBase),
    // $this->wrappers may be empty although wrappers are still registered
    // globally. Thus an isset() check is needed before iterating.
    if (isset($this->wrappers[StreamWrapperInterface::ALL])) {
      foreach (array_keys($this->wrappers[StreamWrapperInterface::ALL]) as $scheme) {
        stream_wrapper_unregister($scheme);
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function registerWrapper($scheme, $class, $type) {
    if (in_array($scheme, stream_get_wrappers(), TRUE)) {
      stream_wrapper_unregister($scheme);
    }
    if (($type & StreamWrapperInterface::LOCAL) == StreamWrapperInterface::LOCAL) {
      stream_wrapper_register($scheme, $class);
    }
    else {
      stream_wrapper_register($scheme, $class, STREAM_IS_URL);
    }

    // Pre-populate the static cache with the filters most typically used.
    $info = array(
      'type' => $type,
      'class' => $class,
    );
    $this->wrappers[StreamWrapperInterface::ALL][$scheme] = $info;
    if (($type & StreamWrapperInterface::WRITE_VISIBLE) == StreamWrapperInterface::WRITE_VISIBLE) {
      $this->wrappers[StreamWrapperInterface::WRITE_VISIBLE][$scheme] = $info;
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ContainerAware::$container	protected	property
ContainerAware::setContainer	public	function	Sets the Container associated with this Controller. Overrides ContainerAwareInterface::setContainer
StreamWrapperManager::$info	protected	property	Contains stream wrapper info.
StreamWrapperManager::$wrappers	protected	property	Contains collected stream wrappers.
StreamWrapperManager::addStreamWrapper	public	function	Adds a stream wrapper.
StreamWrapperManager::getClass	public	function	Returns the stream wrapper class name for a given scheme. Overrides StreamWrapperManagerInterface::getClass
StreamWrapperManager::getDescriptions	public	function	Returns registered stream wrapper descriptions. Overrides StreamWrapperManagerInterface::getDescriptions
StreamWrapperManager::getNames	public	function	Returns registered stream wrapper names. Overrides StreamWrapperManagerInterface::getNames
StreamWrapperManager::getViaScheme	public	function	Returns a reference to the stream wrapper class responsible for a scheme. Overrides StreamWrapperManagerInterface::getViaScheme
StreamWrapperManager::getViaUri	public	function	Returns a reference to the stream wrapper class responsible for a URI. Overrides StreamWrapperManagerInterface::getViaUri
StreamWrapperManager::getWrapper	protected	function	Returns a stream wrapper instance.
StreamWrapperManager::getWrappers	public	function	Provides Drupal stream wrapper registry. Overrides StreamWrapperManagerInterface::getWrappers
StreamWrapperManager::register	public	function	Registers the tagged stream wrappers.
StreamWrapperManager::registerWrapper	public	function	Registers stream wrapper with PHP. Overrides StreamWrapperManagerInterface::registerWrapper
StreamWrapperManager::unregister	public	function	Unregisters the tagged stream wrappers.