--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vendor/swiftmailer/lib/classes/Swift/DependencyContainer.php Sat Sep 24 15:40:41 2011 +0200
@@ -0,0 +1,348 @@
+<?php
+
+/*
+ * This file is part of SwiftMailer.
+ * (c) 2004-2009 Chris Corbyn
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+
+/**
+ * Dependency Injection container.
+ * @package Swift
+ * @author Chris Corbyn
+ */
+class Swift_DependencyContainer
+{
+
+ /** Constant for literal value types */
+ const TYPE_VALUE = 0x0001;
+
+ /** Constant for new instance types */
+ const TYPE_INSTANCE = 0x0010;
+
+ /** Constant for shared instance types */
+ const TYPE_SHARED = 0x0100;
+
+ /** Constant for aliases */
+ const TYPE_ALIAS = 0x1000;
+
+ /** Singleton instance */
+ private static $_instance = null;
+
+ /** The data container */
+ private $_store = array();
+
+ /** The current endpoint in the data container */
+ private $_endPoint;
+
+ /**
+ * Constructor should not be used.
+ * Use {@link getInstance()} instead.
+ */
+ public function __construct() { }
+
+ /**
+ * Returns a singleton of the DependencyContainer.
+ * @return Swift_DependencyContainer
+ */
+ public static function getInstance()
+ {
+ if (!isset(self::$_instance))
+ {
+ self::$_instance = new self();
+ }
+ return self::$_instance;
+ }
+
+ /**
+ * List the names of all items stored in the Container.
+ * @return array
+ */
+ public function listItems()
+ {
+ return array_keys($this->_store);
+ }
+
+ /**
+ * Test if an item is registered in this container with the given name.
+ * @param string $itemName
+ * @return boolean
+ * @see register()
+ */
+ public function has($itemName)
+ {
+ return array_key_exists($itemName, $this->_store)
+ && isset($this->_store[$itemName]['lookupType']);
+ }
+
+ /**
+ * Lookup the item with the given $itemName.
+ * @param string $itemName
+ * @return mixed
+ * @throws Swift_DependencyException If the dependency is not found
+ * @see register()
+ */
+ public function lookup($itemName)
+ {
+ if (!$this->has($itemName))
+ {
+ throw new Swift_DependencyException(
+ 'Cannot lookup dependency "' . $itemName . '" since it is not registered.'
+ );
+ }
+
+ switch ($this->_store[$itemName]['lookupType'])
+ {
+ case self::TYPE_ALIAS:
+ return $this->_createAlias($itemName);
+ case self::TYPE_VALUE:
+ return $this->_getValue($itemName);
+ case self::TYPE_INSTANCE:
+ return $this->_createNewInstance($itemName);
+ case self::TYPE_SHARED:
+ return $this->_createSharedInstance($itemName);
+ }
+ }
+
+ /**
+ * Create an array of arguments passed to the constructor of $itemName.
+ * @param string $itemName
+ * @return array
+ */
+ public function createDependenciesFor($itemName)
+ {
+ $args = array();
+ if (isset($this->_store[$itemName]['args']))
+ {
+ $args = $this->_resolveArgs($this->_store[$itemName]['args']);
+ }
+ return $args;
+ }
+
+ /**
+ * Register a new dependency with $itemName.
+ * This method returns the current DependencyContainer instance because it
+ * requires the use of the fluid interface to set the specific details for the
+ * dependency.
+ *
+ * @param string $itemName
+ * @return Swift_DependencyContainer
+ * @see asNewInstanceOf(), asSharedInstanceOf(), asValue()
+ */
+ public function register($itemName)
+ {
+ $this->_store[$itemName] = array();
+ $this->_endPoint =& $this->_store[$itemName];
+ return $this;
+ }
+
+ /**
+ * Specify the previously registered item as a literal value.
+ * {@link register()} must be called before this will work.
+ *
+ * @param mixed $value
+ * @return Swift_DependencyContainer
+ */
+ public function asValue($value)
+ {
+ $endPoint =& $this->_getEndPoint();
+ $endPoint['lookupType'] = self::TYPE_VALUE;
+ $endPoint['value'] = $value;
+ return $this;
+ }
+
+ /**
+ * Specify the previously registered item as an alias of another item.
+ * @param string $lookup
+ * @return Swift_DependencyContainer
+ */
+ public function asAliasOf($lookup)
+ {
+ $endPoint =& $this->_getEndPoint();
+ $endPoint['lookupType'] = self::TYPE_ALIAS;
+ $endPoint['ref'] = $lookup;
+ return $this;
+ }
+
+ /**
+ * Specify the previously registered item as a new instance of $className.
+ * {@link register()} must be called before this will work.
+ * Any arguments can be set with {@link withDependencies()},
+ * {@link addConstructorValue()} or {@link addConstructorLookup()}.
+ *
+ * @param string $className
+ * @return Swift_DependencyContainer
+ * @see withDependencies(), addConstructorValue(), addConstructorLookup()
+ */
+ public function asNewInstanceOf($className)
+ {
+ $endPoint =& $this->_getEndPoint();
+ $endPoint['lookupType'] = self::TYPE_INSTANCE;
+ $endPoint['className'] = $className;
+ return $this;
+ }
+
+ /**
+ * Specify the previously registered item as a shared instance of $className.
+ * {@link register()} must be called before this will work.
+ * @param string $className
+ * @return Swift_DependencyContainer
+ */
+ public function asSharedInstanceOf($className)
+ {
+ $endPoint =& $this->_getEndPoint();
+ $endPoint['lookupType'] = self::TYPE_SHARED;
+ $endPoint['className'] = $className;
+ return $this;
+ }
+
+ /**
+ * Specify a list of injected dependencies for the previously registered item.
+ * This method takes an array of lookup names.
+ *
+ * @param array $lookups
+ * @return Swift_DependencyContainer
+ * @see addConstructorValue(), addConstructorLookup()
+ */
+ public function withDependencies(array $lookups)
+ {
+ $endPoint =& $this->_getEndPoint();
+ $endPoint['args'] = array();
+ foreach ($lookups as $lookup)
+ {
+ $this->addConstructorLookup($lookup);
+ }
+ return $this;
+ }
+
+ /**
+ * Specify a literal (non looked up) value for the constructor of the
+ * previously registered item.
+ *
+ * @param mixed $value
+ * @return Swift_DependencyContainer
+ * @see withDependencies(), addConstructorLookup()
+ */
+ public function addConstructorValue($value)
+ {
+ $endPoint =& $this->_getEndPoint();
+ if (!isset($endPoint['args']))
+ {
+ $endPoint['args'] = array();
+ }
+ $endPoint['args'][] = array('type' => 'value', 'item' => $value);
+ return $this;
+ }
+
+ /**
+ * Specify a dependency lookup for the constructor of the previously
+ * registered item.
+ *
+ * @param string $lookup
+ * @return Swift_DependencyContainer
+ * @see withDependencies(), addConstructorValue()
+ */
+ public function addConstructorLookup($lookup)
+ {
+ $endPoint =& $this->_getEndPoint();
+ if (!isset($this->_endPoint['args']))
+ {
+ $endPoint['args'] = array();
+ }
+ $endPoint['args'][] = array('type' => 'lookup', 'item' => $lookup);
+ return $this;
+ }
+
+ // -- Private methods
+
+ /** Get the literal value with $itemName */
+ private function _getValue($itemName)
+ {
+ return $this->_store[$itemName]['value'];
+ }
+
+ /** Resolve an alias to another item */
+ private function _createAlias($itemName)
+ {
+ return $this->lookup($this->_store[$itemName]['ref']);
+ }
+
+ /** Create a fresh instance of $itemName */
+ private function _createNewInstance($itemName)
+ {
+ $reflector = new ReflectionClass($this->_store[$itemName]['className']);
+ if ($reflector->getConstructor())
+ {
+ return $reflector->newInstanceArgs(
+ $this->createDependenciesFor($itemName)
+ );
+ }
+ else
+ {
+ return $reflector->newInstance();
+ }
+ }
+
+ /** Create and register a shared instance of $itemName */
+ private function _createSharedInstance($itemName)
+ {
+ if (!isset($this->_store[$itemName]['instance']))
+ {
+ $this->_store[$itemName]['instance'] = $this->_createNewInstance($itemName);
+ }
+ return $this->_store[$itemName]['instance'];
+ }
+
+ /** Get the current endpoint in the store */
+ private function &_getEndPoint()
+ {
+ if (!isset($this->_endPoint))
+ {
+ throw new BadMethodCallException(
+ 'Component must first be registered by calling register()'
+ );
+ }
+ return $this->_endPoint;
+ }
+
+ /** Get an argument list with dependencies resolved */
+ private function _resolveArgs(array $args)
+ {
+ $resolved = array();
+ foreach ($args as $argDefinition)
+ {
+ switch ($argDefinition['type'])
+ {
+ case 'lookup':
+ $resolved[] = $this->_lookupRecursive($argDefinition['item']);
+ break;
+ case 'value':
+ $resolved[] = $argDefinition['item'];
+ break;
+ }
+ }
+ return $resolved;
+ }
+
+ /** Resolve a single dependency with an collections */
+ private function _lookupRecursive($item)
+ {
+ if (is_array($item))
+ {
+ $collection = array();
+ foreach ($item as $k => $v)
+ {
+ $collection[$k] = $this->_lookupRecursive($v);
+ }
+ return $collection;
+ }
+ else
+ {
+ return $this->lookup($item);
+ }
+ }
+
+}