Example #1
0
 /**
  * {@inheritdoc}
  */
 public function register()
 {
     $dic = $this->app->getContainer();
     $dic->define('Autarky\\Logging\\ChannelManager', function () {
         return new ChannelManager();
     });
     $dic->share('Autarky\\Logging\\ChannelManager');
     $factory = new Definition(['Autarky\\Logging\\ChannelManager', 'getChannel']);
     $factory->addScalarArgument('$channel', 'string', false, null);
     $dic->define('Psr\\Log\\LoggerInterface', $factory);
 }
Example #2
0
 /**
  * {@inheritdoc}
  */
 public function register()
 {
     $dic = $this->app->getContainer();
     $dic->share('Autarky\\Database\\PDOInstantiator');
     $dic->alias('Autarky\\Database\\PDOInstantiator', 'Autarky\\Database\\PDOInstantiatorInterface');
     $dic->share('Autarky\\Database\\ConnectionFactory');
     $dic->alias('Autarky\\Database\\ConnectionFactory', 'Autarky\\Database\\ConnectionFactoryInterface');
     $dic->define('Autarky\\Database\\ConnectionManager', function (ContainerInterface $dic) {
         return new ConnectionManager($this->app->getConfig(), $dic->resolve('Autarky\\Database\\ConnectionFactoryInterface'));
     });
     $dic->share('Autarky\\Database\\ConnectionManager');
     $factory = new Definition(['Autarky\\Database\\ConnectionManager', 'getPdo']);
     $factory->addScalarArgument('$connection', 'string', false, null);
     $dic->define('PDO', $factory);
 }
Example #3
0
 protected function resolveScalarArg(ContainerInterface $container, ScalarArgument $arg, array $params)
 {
     $name = $arg->getName();
     if ($params && array_key_exists($name, $params)) {
         return $params[$name];
     }
     if (!$arg->isRequired()) {
         return $arg->getDefault();
     }
     $pos = $arg->getPosition() + 1;
     $defName = $this->definition->getName();
     $message = "Unresolvable argument: Argument #{$pos} ({$name}) of {$defName}" . ' - Argument is required and has no value';
     throw new UnresolvableArgumentException($message);
 }
Example #4
0
 /**
  * Get the existing factory for a class. If a factory is not already defined
  * a default one will be created via reflection.
  *
  * @param  string $class  Name of the class
  * @param  array  $params Optional
  *
  * @return FactoryInterface
  */
 public function getFactory($class, array $params = array())
 {
     if (!isset($this->factories[$class]) && $this->autowire) {
         $this->factories[$class] = Definition::getDefaultForClass($class);
     }
     $factory = $this->factories[$class];
     // if $params is defined, we need to either make a copy of the existing
     // Factory or make the Definition create a new factory with the params
     if ($params) {
         $factory = $factory->getFactory($params);
     }
     return $factory;
 }
Example #5
0
 /**
  * Add arguments to an existing factory via reflection.
  *
  * @param Definition                      $factory
  * @param ReflectionFunctionAbstract|null $reflectionFunction Optional
  */
 protected static function addReflectionArguments(Definition $factory, ReflectionFunctionAbstract $reflectionFunction = null)
 {
     if (!$reflectionFunction) {
         $callable = $factory->getCallable();
         if (is_array($callable)) {
             $reflectionFunction = new ReflectionMethod($callable[0], $callable[1]);
         } else {
             $reflectionFunction = new ReflectionFunction($callable);
         }
     }
     foreach ($reflectionFunction->getParameters() as $arg) {
         try {
             $name = $arg->getName();
             $required = !$arg->isOptional();
             if ($argClass = $arg->getClass()) {
                 $factory->addClassArgument($name, $argClass->getName(), $required);
             } else {
                 $default = $required ? null : $arg->getDefaultValue();
                 $factory->addScalarArgument($name, null, $required, $default);
             }
         } catch (ReflectionException $re) {
             throw UnresolvableArgumentException::fromReflectionParam($arg, $reflectionFunction, $re);
         }
     }
 }