You are here

abstract class FileDriver in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileDriver.php \Doctrine\Common\Persistence\Mapping\Driver\FileDriver

Base driver for file-based metadata drivers.

A file driver operates in a mode where it loads the mapping files of individual classes on demand. This requires the user to adhere to the convention of 1 mapping file per class and the file names of the mapping files must correspond to the full class name, including namespace, with the namespace delimiters '\', replaced by dots '.'.

@link www.doctrine-project.org @since 2.2 @author Benjamin Eberlei <kontakt@beberlei.de> @author Guilherme Blanco <guilhermeblanco@hotmail.com> @author Jonathan H. Wage <jonwage@gmail.com> @author Roman Borschel <roman@code-factory.org>

Hierarchy

Expanded class hierarchy of FileDriver

1 file declares its use of FileDriver
FileDriverTest.php in vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/FileDriverTest.php

File

vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileDriver.php, line 39

Namespace

Doctrine\Common\Persistence\Mapping\Driver
View source
abstract class FileDriver implements MappingDriver {

  /**
   * @var FileLocator
   */
  protected $locator;

  /**
   * @var array|null
   */
  protected $classCache;

  /**
   * @var string|null
   */
  protected $globalBasename;

  /**
   * Initializes a new FileDriver that looks in the given path(s) for mapping
   * documents and operates in the specified operating mode.
   *
   * @param string|array|FileLocator $locator       A FileLocator or one/multiple paths
   *                                                where mapping documents can be found.
   * @param string|null              $fileExtension
   */
  public function __construct($locator, $fileExtension = null) {
    if ($locator instanceof FileLocator) {
      $this->locator = $locator;
    }
    else {
      $this->locator = new DefaultFileLocator((array) $locator, $fileExtension);
    }
  }

  /**
   * Sets the global basename.
   *
   * @param string $file
   *
   * @return void
   */
  public function setGlobalBasename($file) {
    $this->globalBasename = $file;
  }

  /**
   * Retrieves the global basename.
   *
   * @return string|null
   */
  public function getGlobalBasename() {
    return $this->globalBasename;
  }

  /**
   * Gets the element of schema meta data for the class from the mapping file.
   * This will lazily load the mapping file if it is not loaded yet.
   *
   * @param string $className
   *
   * @return array The element of schema meta data.
   *
   * @throws MappingException
   */
  public function getElement($className) {
    if ($this->classCache === null) {
      $this
        ->initialize();
    }
    if (isset($this->classCache[$className])) {
      return $this->classCache[$className];
    }
    $result = $this
      ->loadMappingFile($this->locator
      ->findMappingFile($className));
    if (!isset($result[$className])) {
      throw MappingException::invalidMappingFile($className, str_replace('\\', '.', $className) . $this->locator
        ->getFileExtension());
    }
    return $result[$className];
  }

  /**
   * {@inheritDoc}
   */
  public function isTransient($className) {
    if ($this->classCache === null) {
      $this
        ->initialize();
    }
    if (isset($this->classCache[$className])) {
      return false;
    }
    return !$this->locator
      ->fileExists($className);
  }

  /**
   * {@inheritDoc}
   */
  public function getAllClassNames() {
    if ($this->classCache === null) {
      $this
        ->initialize();
    }
    $classNames = (array) $this->locator
      ->getAllClassNames($this->globalBasename);
    if ($this->classCache) {
      $classNames = array_merge(array_keys($this->classCache), $classNames);
    }
    return $classNames;
  }

  /**
   * Loads a mapping file with the given name and returns a map
   * from class/entity names to their corresponding file driver elements.
   *
   * @param string $file The mapping file to load.
   *
   * @return array
   */
  protected abstract function loadMappingFile($file);

  /**
   * Initializes the class cache from all the global files.
   *
   * Using this feature adds a substantial performance hit to file drivers as
   * more metadata has to be loaded into memory than might actually be
   * necessary. This may not be relevant to scenarios where caching of
   * metadata is in place, however hits very hard in scenarios where no
   * caching is used.
   *
   * @return void
   */
  protected function initialize() {
    $this->classCache = array();
    if (null !== $this->globalBasename) {
      foreach ($this->locator
        ->getPaths() as $path) {
        $file = $path . '/' . $this->globalBasename . $this->locator
          ->getFileExtension();
        if (is_file($file)) {
          $this->classCache = array_merge($this->classCache, $this
            ->loadMappingFile($file));
        }
      }
    }
  }

  /**
   * Retrieves the locator used to discover mapping files by className.
   *
   * @return FileLocator
   */
  public function getLocator() {
    return $this->locator;
  }

  /**
   * Sets the locator used to discover mapping files by className.
   *
   * @param FileLocator $locator
   */
  public function setLocator(FileLocator $locator) {
    $this->locator = $locator;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
FileDriver::$classCache protected property
FileDriver::$globalBasename protected property
FileDriver::$locator protected property
FileDriver::getAllClassNames public function Gets the names of all mapped classes known to this driver. Overrides MappingDriver::getAllClassNames
FileDriver::getElement public function Gets the element of schema meta data for the class from the mapping file. This will lazily load the mapping file if it is not loaded yet.
FileDriver::getGlobalBasename public function Retrieves the global basename.
FileDriver::getLocator public function Retrieves the locator used to discover mapping files by className.
FileDriver::initialize protected function Initializes the class cache from all the global files.
FileDriver::isTransient public function Returns whether the class with the specified name should have its metadata loaded. This is only the case if it is either mapped as an Entity or a MappedSuperclass. Overrides MappingDriver::isTransient
FileDriver::loadMappingFile abstract protected function Loads a mapping file with the given name and returns a map from class/entity names to their corresponding file driver elements. 2
FileDriver::setGlobalBasename public function Sets the global basename.
FileDriver::setLocator public function Sets the locator used to discover mapping files by className.
FileDriver::__construct public function Initializes a new FileDriver that looks in the given path(s) for mapping documents and operates in the specified operating mode. 1
MappingDriver::loadMetadataForClass public function Loads the metadata for the specified class into the provided container. 5