vendor/swiftmailer/swiftmailer/lib/classes/Swift/DependencyContainer.php line 109

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of SwiftMailer.
  5.  * (c) 2004-2009 Chris Corbyn
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  11. /**
  12.  * Dependency Injection container.
  13.  *
  14.  * @author  Chris Corbyn
  15.  */
  16. class Swift_DependencyContainer
  17. {
  18.     /** Constant for literal value types */
  19.     const TYPE_VALUE = 0x00001;
  21.     /** Constant for new instance types */
  22.     const TYPE_INSTANCE = 0x00010;
  24.     /** Constant for shared instance types */
  25.     const TYPE_SHARED = 0x00100;
  27.     /** Constant for aliases */
  28.     const TYPE_ALIAS = 0x01000;
  30.     /** Constant for arrays */
  31.     const TYPE_ARRAY = 0x10000;
  33.     /** Singleton instance */
  34.     private static $instance = null;
  36.     /** The data container */
  37.     private $store = [];
  39.     /** The current endpoint in the data container */
  40.     private $endPoint;
  42.     /**
  43.      * Constructor should not be used.
  44.      *
  45.      * Use {@link getInstance()} instead.
  46.      */
  47.     public function __construct()
  48.     {
  49.     }
  51.     /**
  52.      * Returns a singleton of the DependencyContainer.
  53.      *
  54.      * @return self
  55.      */
  56.     public static function getInstance()
  57.     {
  58.         if (!isset(self::$instance)) {
  59.             self::$instance = new self();
  60.         }
  62.         return self::$instance;
  63.     }
  65.     /**
  66.      * List the names of all items stored in the Container.
  67.      *
  68.      * @return array
  69.      */
  70.     public function listItems()
  71.     {
  72.         return array_keys($this->store);
  73.     }
  75.     /**
  76.      * Test if an item is registered in this container with the given name.
  77.      *
  78.      * @see register()
  79.      *
  80.      * @param string $itemName
  81.      *
  82.      * @return bool
  83.      */
  84.     public function has($itemName)
  85.     {
  86.         return \array_key_exists($itemName, $this->store)
  87.             && isset($this->store[$itemName]['lookupType']);
  88.     }
  90.     /**
  91.      * Lookup the item with the given $itemName.
  92.      *
  93.      * @see register()
  94.      *
  95.      * @param string $itemName
  96.      *
  97.      * @return mixed
  98.      *
  99.      * @throws Swift_DependencyException If the dependency is not found
  100.      */
  101.     public function lookup($itemName)
  102.     {
  103.         if (!$this->has($itemName)) {
  104.             throw new Swift_DependencyException('Cannot lookup dependency "'.$itemName.'" since it is not registered.');
  105.         }
  107.         switch ($this->store[$itemName]['lookupType']) {
  108.             case self::TYPE_ALIAS:
  109.                 return $this->createAlias($itemName);
  110.             case self::TYPE_VALUE:
  111.                 return $this->getValue($itemName);
  112.             case self::TYPE_INSTANCE:
  113.                 return $this->createNewInstance($itemName);
  114.             case self::TYPE_SHARED:
  115.                 return $this->createSharedInstance($itemName);
  116.             case self::TYPE_ARRAY:
  117.                 return $this->createDependenciesFor($itemName);
  118.         }
  119.     }
  121.     /**
  122.      * Create an array of arguments passed to the constructor of $itemName.
  123.      *
  124.      * @param string $itemName
  125.      *
  126.      * @return array
  127.      */
  128.     public function createDependenciesFor($itemName)
  129.     {
  130.         $args = [];
  131.         if (isset($this->store[$itemName]['args'])) {
  132.             $args = $this->resolveArgs($this->store[$itemName]['args']);
  133.         }
  135.         return $args;
  136.     }
  138.     /**
  139.      * Register a new dependency with $itemName.
  140.      *
  141.      * This method returns the current DependencyContainer instance because it
  142.      * requires the use of the fluid interface to set the specific details for the
  143.      * dependency.
  144.      *
  145.      * @see asNewInstanceOf(), asSharedInstanceOf(), asValue()
  146.      *
  147.      * @param string $itemName
  148.      *
  149.      * @return $this
  150.      */
  151.     public function register($itemName)
  152.     {
  153.         $this->store[$itemName] = [];
  154.         $this->endPoint = &$this->store[$itemName];
  156.         return $this;
  157.     }
  159.     /**
  160.      * Specify the previously registered item as a literal value.
  161.      *
  162.      * {@link register()} must be called before this will work.
  163.      *
  164.      * @param mixed $value
  165.      *
  166.      * @return $this
  167.      */
  168.     public function asValue($value)
  169.     {
  170.         $endPoint = &$this->getEndPoint();
  171.         $endPoint['lookupType'] = self::TYPE_VALUE;
  172.         $endPoint['value'] = $value;
  174.         return $this;
  175.     }
  177.     /**
  178.      * Specify the previously registered item as an alias of another item.
  179.      *
  180.      * @param string $lookup
  181.      *
  182.      * @return $this
  183.      */
  184.     public function asAliasOf($lookup)
  185.     {
  186.         $endPoint = &$this->getEndPoint();
  187.         $endPoint['lookupType'] = self::TYPE_ALIAS;
  188.         $endPoint['ref'] = $lookup;
  190.         return $this;
  191.     }
  193.     /**
  194.      * Specify the previously registered item as a new instance of $className.
  195.      *
  196.      * {@link register()} must be called before this will work.
  197.      * Any arguments can be set with {@link withDependencies()},
  198.      * {@link addConstructorValue()} or {@link addConstructorLookup()}.
  199.      *
  200.      * @see withDependencies(), addConstructorValue(), addConstructorLookup()
  201.      *
  202.      * @param string $className
  203.      *
  204.      * @return $this
  205.      */
  206.     public function asNewInstanceOf($className)
  207.     {
  208.         $endPoint = &$this->getEndPoint();
  209.         $endPoint['lookupType'] = self::TYPE_INSTANCE;
  210.         $endPoint['className'] = $className;
  212.         return $this;
  213.     }
  215.     /**
  216.      * Specify the previously registered item as a shared instance of $className.
  217.      *
  218.      * {@link register()} must be called before this will work.
  219.      *
  220.      * @param string $className
  221.      *
  222.      * @return $this
  223.      */
  224.     public function asSharedInstanceOf($className)
  225.     {
  226.         $endPoint = &$this->getEndPoint();
  227.         $endPoint['lookupType'] = self::TYPE_SHARED;
  228.         $endPoint['className'] = $className;
  230.         return $this;
  231.     }
  233.     /**
  234.      * Specify the previously registered item as array of dependencies.
  235.      *
  236.      * {@link register()} must be called before this will work.
  237.      *
  238.      * @return $this
  239.      */
  240.     public function asArray()
  241.     {
  242.         $endPoint = &$this->getEndPoint();
  243.         $endPoint['lookupType'] = self::TYPE_ARRAY;
  245.         return $this;
  246.     }
  248.     /**
  249.      * Specify a list of injected dependencies for the previously registered item.
  250.      *
  251.      * This method takes an array of lookup names.
  252.      *
  253.      * @see addConstructorValue(), addConstructorLookup()
  254.      *
  255.      * @return $this
  256.      */
  257.     public function withDependencies(array $lookups)
  258.     {
  259.         $endPoint = &$this->getEndPoint();
  260.         $endPoint['args'] = [];
  261.         foreach ($lookups as $lookup) {
  262.             $this->addConstructorLookup($lookup);
  263.         }
  265.         return $this;
  266.     }
  268.     /**
  269.      * Specify a literal (non looked up) value for the constructor of the
  270.      * previously registered item.
  271.      *
  272.      * @see withDependencies(), addConstructorLookup()
  273.      *
  274.      * @param mixed $value
  275.      *
  276.      * @return $this
  277.      */
  278.     public function addConstructorValue($value)
  279.     {
  280.         $endPoint = &$this->getEndPoint();
  281.         if (!isset($endPoint['args'])) {
  282.             $endPoint['args'] = [];
  283.         }
  284.         $endPoint['args'][] = ['type' => 'value', 'item' => $value];
  286.         return $this;
  287.     }
  289.     /**
  290.      * Specify a dependency lookup for the constructor of the previously
  291.      * registered item.
  292.      *
  293.      * @see withDependencies(), addConstructorValue()
  294.      *
  295.      * @param string $lookup
  296.      *
  297.      * @return $this
  298.      */
  299.     public function addConstructorLookup($lookup)
  300.     {
  301.         $endPoint = &$this->getEndPoint();
  302.         if (!isset($this->endPoint['args'])) {
  303.             $endPoint['args'] = [];
  304.         }
  305.         $endPoint['args'][] = ['type' => 'lookup', 'item' => $lookup];
  307.         return $this;
  308.     }
  310.     /** Get the literal value with $itemName */
  311.     private function getValue($itemName)
  312.     {
  313.         return $this->store[$itemName]['value'];
  314.     }
  316.     /** Resolve an alias to another item */
  317.     private function createAlias($itemName)
  318.     {
  319.         return $this->lookup($this->store[$itemName]['ref']);
  320.     }
  322.     /** Create a fresh instance of $itemName */
  323.     private function createNewInstance($itemName)
  324.     {
  325.         $reflector = new ReflectionClass($this->store[$itemName]['className']);
  326.         if ($reflector->getConstructor()) {
  327.             return $reflector->newInstanceArgs(
  328.                 $this->createDependenciesFor($itemName)
  329.                 );
  330.         }
  332.         return $reflector->newInstance();
  333.     }
  335.     /** Create and register a shared instance of $itemName */
  336.     private function createSharedInstance($itemName)
  337.     {
  338.         if (!isset($this->store[$itemName]['instance'])) {
  339.             $this->store[$itemName]['instance'] = $this->createNewInstance($itemName);
  340.         }
  342.         return $this->store[$itemName]['instance'];
  343.     }
  345.     /** Get the current endpoint in the store */
  346.     private function &getEndPoint()
  347.     {
  348.         if (!isset($this->endPoint)) {
  349.             throw new BadMethodCallException('Component must first be registered by calling register()');
  350.         }
  352.         return $this->endPoint;
  353.     }
  355.     /** Get an argument list with dependencies resolved */
  356.     private function resolveArgs(array $args)
  357.     {
  358.         $resolved = [];
  359.         foreach ($args as $argDefinition) {
  360.             switch ($argDefinition['type']) {
  361.                 case 'lookup':
  362.                     $resolved[] = $this->lookupRecursive($argDefinition['item']);
  363.                     break;
  364.                 case 'value':
  365.                     $resolved[] = $argDefinition['item'];
  366.                     break;
  367.             }
  368.         }
  370.         return $resolved;
  371.     }
  373.     /** Resolve a single dependency with an collections */
  374.     private function lookupRecursive($item)
  375.     {
  376.         if (\is_array($item)) {
  377.             $collection = [];
  378.             foreach ($item as $k => $v) {
  379.                 $collection[$k] = $this->lookupRecursive($v);
  380.             }
  382.             return $collection;
  383.         }
  385.         return $this->lookup($item);
  386.     }
  387. }