• Navigation
• Constructor
• Static factory
• Construct from array
•  Constructor Arguments
• Add raw argument
• Add dependency argument
• Add parameter argument
• Get all arguments
• Get service class name
• Method Calls
• Add a method call (with array)
• Add a method call
• Interface

Service Definitions

A service definition acts as a simple description of a service. But it does not hold container relevant informations like the alias name or if the service will be shared or not.

This package comes already with an implementation of the ServiceDefinitionInterface simply called ServiceDefinition.

#  Constructor

public function __construct(string $className, array $arguments = [])

Create a new service definition:

use ClanCats\Container\ServiceDefinition;

$logger = new ServiceDefinition(MyLogger::class);

You can also directly pass the constructor arguments as an array:

$logger = new ServiceDefinition(MyLogger::class, ['@some_dependency', ':some_parameter', 42]);

Keep in mind when passing arguments as an array prefixing a string with @ will be interpreted as a dependency and : as parameter. This applies everywhere arguments are defined as array. Service Arguments

#  Static factory

There is also a static method to construct new service definition instance allowing a more expressive syntax.

ServiceDefinition::for('\Acme\SessionService')
   ->addDependencyArgument('storage')
   ->addParameterArgument('session_token')
   ->addRawArgument(600)

ServiceDefinition::for('\Acme\SessionService', ['@storage', ':session_token', 600])

public static function for(string $serviceClassName, array $arguments = [])

#  Construct from array

ServiceDefinition::fromArray([
    'class' => '\Acme\Demo',
    'arguments' => ['@foo', ':bar'],
    'calls' => [
        ['method' => 'setName', [':demo.name']]
    ]
])

public static function fromArray(array $serviceConfiguration)

#   Constructor Arguments

You can pass additional constructor arguments any time:

$QA = new ServiceDefinition(QA::class);

$QA
    ->addRawArgument('The Answer to the Ultimate Question of Life, The Universe, and Everything.');
    ->addRawArgument(42)
    ->addDependencyArgument('database')
    ->addParameterArgument('priority.default');

Using the arguments method you can also pass them as an array.

$auth = new ServiceDefinition(MyAuth::class)
    ->arguments([
        '@repository.users',
        ':auth.secret'
    ]);

#  Add raw argument

public function addRawArgument($argumentValue) : ServiceDefinition

$def = ServiceDefinition::for('\Acme\SqlConnection')
    ->addRawArgument('localhost')
    ->addRawArgument('root')
    ->addRawArgument('pleaseDontUseRoot');

#  Add dependency argument

public function addDependencyArgument($argumentValue) : ServiceDefinition

$def = ServiceDefinition::for('\Acme\Blog\PostRepository')
    ->addDependencyArgument('db.connection');

#  Add parameter argument

public function addParameterArgument($argumentValue) : ServiceDefinition

$def = ServiceDefinition::for('\Acme\Session')
    ->addParameterArgument('session.secret');

#  Get all arguments

public function getArguments() : ServiceArguments

$definition->getArguments(); // ServiceArguments instance

#  Get service class name

public function getClassName() : string

#  Method Calls

A service definition can hold method calls that have to be called on construction, these can set dependencies, parameters or raw values just like the constructor arguments.

#  Add a method call (with array)

public function calls(string $method, array $arguments = []) : ServiceDefinition

$def = ServiceDefinition::for('\Acme\Session')
    ->calls('setEventDispatcher', ['@event_dispatcher']);

#  Add a method call

public function addMethodCall(string $methodName, ServiceArguments $arguments) : ServiceDefinition

$eventDispatchetArgs = (new ServiceArguments())
    ->addDependencyArgument('event_dispatcher');

$sessionDefinition = ServiceDefinition::for('\Acme\Session')
    ->addMethodCall('setEventDispatcher', $eventDispatchetArgs);

#  Interface

Any class that will be used as a service definition must implement the ServiceDefinitionInterface which requires the following methods:

Return the service class name

public function getClassName() : string;

Return the constructor arguments object

public function getArguments() : ServiceArguments;

Return the registered method calls

public function getMethodCalls() : array;

The format of the returned array should look like [string => ServiceArguments].