1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
<?php
namespace Automattic\WooCommerce\Blocks\Registry;
use Closure;
use Exception;
/**
* A simple Dependency Injection Container
*
* This is used to manage dependencies used throughout the plugin.
*
* @since 2.5.0
*/
class Container {
/**
* A map of Dependency Type objects used to resolve dependencies.
*
* @var AbstractDependencyType[]
*/
private $registry = [];
/**
* Public api for adding a factory to the container.
*
* Factory dependencies will have the instantiation callback invoked
* every time the dependency is requested.
*
* Typical Usage:
*
* ```
* $container->register( MyClass::class, $container->factory( $mycallback ) );
* ```
*
* @param Closure $instantiation_callback This will be invoked when the
* dependency is required. It will
* receive an instance of this
* container so the callback can
* retrieve dependencies from the
* container.
*
* @return FactoryType An instance of the FactoryType dependency.
*/
public function factory( Closure $instantiation_callback ) {
return new FactoryType( $instantiation_callback );
}
/**
* Interface for registering a new dependency with the container.
*
* By default, the $value will be added as a shared dependency. This means
* that it will be a single instance shared among any other classes having
* that dependency.
*
* If you want a new instance every time it's required, then wrap the value
* in a call to the factory method (@see Container::factory for example)
*
* Note: Currently if the provided id already is registered in the container,
* the provided value is ignored.
*
* @param string $id A unique string identifier for the provided value.
* Typically it's the fully qualified name for the
* dependency.
* @param mixed $value The value for the dependency. Typically, this is a
* closure that will create the class instance needed.
*/
public function register( $id, $value ) {
if ( empty( $this->registry[ $id ] ) ) {
if ( ! $value instanceof FactoryType ) {
$value = new SharedType( $value );
}
$this->registry[ $id ] = $value;
}
}
/**
* Interface for retrieving the dependency stored in the container for the
* given identifier.
*
* @param string $id The identifier for the dependency being retrieved.
* @throws Exception If there is no dependency for the given identifier in
* the container.
*
* @return mixed Typically a class instance.
*/
public function get( $id ) {
if ( ! isset( $this->registry[ $id ] ) ) {
// this is a developer facing exception, hence it is not localized.
throw new Exception(
sprintf(
'Cannot construct an instance of %s because it has not been registered.',
$id
)
);
}
return $this->registry[ $id ]->get( $this );
}
}
|