class ReflectionFactory

Same name in other branches
  1. 9 core/lib/Drupal/Component/Plugin/Factory/ReflectionFactory.php \Drupal\Component\Plugin\Factory\ReflectionFactory
  2. 10 core/lib/Drupal/Component/Plugin/Factory/ReflectionFactory.php \Drupal\Component\Plugin\Factory\ReflectionFactory
  3. 11.x core/lib/Drupal/Component/Plugin/Factory/ReflectionFactory.php \Drupal\Component\Plugin\Factory\ReflectionFactory

A plugin factory that maps instance configuration to constructor arguments.

Provides logic for any basic plugin type that needs to provide individual plugins based upon some basic logic.

Hierarchy

Expanded class hierarchy of ReflectionFactory

2 files declare their use of ReflectionFactory
MockBlockManager.php in core/modules/system/tests/modules/plugin_test/src/Plugin/MockBlockManager.php
ReflectionFactoryTest.php in core/tests/Drupal/Tests/Component/Plugin/Factory/ReflectionFactoryTest.php
Contains \Drupal\Tests\Component\Plugin\Factory\ReflectionFactoryTest.

File

core/lib/Drupal/Component/Plugin/Factory/ReflectionFactory.php, line 11

Namespace

Drupal\Component\Plugin\Factory
View source 
class ReflectionFactory extends DefaultFactory {
    
    /**
     * {@inheritdoc}
     */
    public function createInstance($plugin_id, array $configuration = []) {
        $plugin_definition = $this->discovery
            ->getDefinition($plugin_id);
        $plugin_class = static::getPluginClass($plugin_id, $plugin_definition, $this->interface);
        // Lets figure out of there's a constructor for this class and pull
        // arguments from the $options array if so to populate it.
        $reflector = new \ReflectionClass($plugin_class);
        if ($reflector->hasMethod('__construct')) {
            $arguments = $this->getInstanceArguments($reflector, $plugin_id, $plugin_definition, $configuration);
            $instance = $reflector->newInstanceArgs($arguments);
        }
        else {
            $instance = new $plugin_class();
        }
        return $instance;
    }
    
    /**
     * Inspects the plugin class and build a list of arguments for the constructor.
     *
     * This is provided as a helper method so factories extending this class can
     * replace this and insert their own reflection logic.
     *
     * @param \ReflectionClass $reflector
     *   The reflector object being used to inspect the plugin class.
     * @param string $plugin_id
     *   The identifier of the plugin implementation.
     * @param mixed $plugin_definition
     *   The definition associated with the plugin_id.
     * @param array $configuration
     *   An array of configuration that may be passed to the instance.
     *
     * @return array
     *   An array of arguments to be passed to the constructor.
     */
    protected function getInstanceArguments(\ReflectionClass $reflector, $plugin_id, $plugin_definition, array $configuration) {
        $arguments = [];
        foreach ($reflector->getMethod('__construct')
            ->getParameters() as $param) {
            $param_name = $param->getName();
            if ($param_name == 'plugin_id') {
                $arguments[] = $plugin_id;
            }
            elseif ($param_name == 'plugin_definition') {
                $arguments[] = $plugin_definition;
            }
            elseif ($param_name == 'configuration') {
                $arguments[] = $configuration;
            }
            elseif (isset($configuration[$param_name]) || array_key_exists($param_name, $configuration)) {
                $arguments[] = $configuration[$param_name];
            }
            elseif ($param->isDefaultValueAvailable()) {
                $arguments[] = $param->getDefaultValue();
            }
            else {
                $arguments[] = NULL;
            }
        }
        return $arguments;
    }

}

Members

Title Modifiers Object type Summary Overriden Title Overrides
DefaultFactory::$discovery protected property The object that retrieves the definitions of the plugins that this factory instantiates.
DefaultFactory::$interface protected property Defines an interface each plugin should implement.
DefaultFactory::getPluginClass public static function Finds the class relevant for a given plugin. 1
DefaultFactory::__construct public function Constructs a Drupal\Component\Plugin\Factory\DefaultFactory object.
ReflectionFactory::createInstance public function Creates a pre-configured instance of a plugin. Overrides DefaultFactory::createInstance
ReflectionFactory::getInstanceArguments protected function Inspects the plugin class and build a list of arguments for the constructor.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.