Wallogit.com
2017 © Pedro Peláez
Simple PSR-11 Complaint Di Container
, (*1)
A Simple PSR-11 Complaint Di Container, (*2)
Install the latest version with:, (*3)
composer require 'corpus/di'
Getting started with Di the three most important methods follow.
- The set method is used to set either the item to return or a lambda to lazily construct it, optionally taking constructor arguments.
- The get method is used to retrieve values with memoization after the initial lazy loading.
- The getNew is used to invoke the lazy loading creation lambda every call, optionally taking an array of constructor arguments as a second parameter., (*4)
<?php
require 'vendor/autoload.php';
$di = new \Corpus\Di\Di;
// Eager Loading
$di->set('foo', new Foo);
$di->get('foo'); // the Foo instance from above
// --- --- --- --- --- ---
// Lazy Loading
$di->set('bar', function () {
return new Bar;
});
// Value is memoized, new Bar() is only called once at first `get`.
$bar1 = $di->get('bar');
$bar2 = $di->get('bar');
// --- --- --- --- --- ---
// Constructor Parameters
$di->set('baz', function ( $qux ) {
return new Baz($qux);
});
// Calling getNew explicitly avoids the memoization. Constructor params passed as array.
$baz = $di->getNew('baz', [ 'corge' ]);
$baz2 = $di->getNew('baz', [ 'grault' ]);
// --- --- --- --- --- ---
// Auto-Constructor Parametrization
$di->set('qux', Qux::class);
$qux1 = $di->get('qux'); // New instance of Qux
$qux2 = $di->get('qux'); // Memoized instance of Qux
// --- --- --- --- --- ---
// Lazy Loading with auto-arguments.
$di->set('quux', function ( Qux $qux ) {
return new Quux($qux);
});
$quux = $di->get('quux'); // Instance of Quux given the previous instance of Qux automatically
// --- --- --- --- --- ---
// getMany lets you retrieve multiple memoized values at once.
[$foo, $bar] = $di->getMany([ 'foo', 'bar' ]);
// getManyNew lets you retrieve multiple new values at once, providing for arguments.
[$baz, $baz2] = $di->getManyNew([ [ 'baz', [ 'corge' ] ], [ 'baz', [ 'grault' ] ] ]);
$di->callFromReflectiveParams(function (Bar $bar, Baz $baz){
// Callable called with parameters automatically populated based on their name
// $bar => 'bar'
});
// Construct a class auto-populating constructor parameters based on their name
$controller1 = $di->constructFromReflectiveParams(MyController::class);
$controller2 = $di->constructFromReflectiveParams('MyController');
function getMany(array $ids) : array
Retrieve multiple item; cached if existing. For use with list(), (*5)
$ids - The names/keys of the itemsfunction get($id)
Finds an entry of the container by its identifier and returns it., (*6)
$id - Identifier of the entry to look for.Throws: \Psr\Container\NotFoundExceptionInterface - No entry was found for this identifier., (*7)
Throws: \Psr\Container\ContainerExceptionInterface - Error while retrieving the entry., (*8)
function getManyNew(array $data) : array
Retrieve multiple item. For use with list(), (*9)
$data - The array of (names/keys / argument) pair tuple of the itemsThrows: \InvalidArgumentException, (*10)
function getNew(string $id [, array $args = []])
Retrieve an item, (*11)
$id - The name/key of the item$args
Throws: \Corpus\Di\Exceptions\UndefinedIdentifierException, (*12)
function duplicate(string $src, string $dest)
Clone a given value into a second key, (*13)
$src - The source$dest - The destinationfunction set(string $id, $value)
Store a value via key to retrieve later, (*14)
$id - The name/key of the item$value - The value to storefunction has($id) : bool
Returns true if the container can return an entry for the given identifier., (*15)
Returns false otherwise., (*16)
has($id) returning true does not mean that get($id) will not throw an exception.
It does however mean that get($id) will not throw a NotFoundExceptionInterface., (*17)
$id - Identifier of the entry to look for.function raw(string $id)
$id - The name/key to be retrievedThrows: \Corpus\Di\Exceptions\UndefinedIdentifierException, (*18)
function constructFromReflectiveParams(string $className [, array $initials = []]) : object
Use reflection to execute a classes constructor with auto-populated parameters, (*19)
$className - The class to construct$initials - An ordered list of arguments to populate initial arguments on constructorfunction callFromReflectiveParams(callable $callable [, array $initials = []])
Use reflection to execute a callable with auto-populated parameters, (*20)
$initials - An ordered list of arguments to populate initial arguments on callableThrown when attempting to retrieve a key that does not exist., (*21)
Simple PSR-11 Complaint Di Container
MIT