abstract class FileDriver in Plug 7

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 <[e-mail]> @author Guilherme Blanco <[e-mail]> @author Jonathan H. Wage <[e-mail]> @author Roman Borschel <[e-mail]>

Hierarchy

• class \Doctrine\Common\Persistence\Mapping\Driver\FileDriver implements MappingDriver

1 file declares its use of FileDriver

FileDriverTest.php in lib/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/FileDriverTest.php

File

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

Namespace

Doctrine\Common\Persistence\Mapping\Driver

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

Name	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