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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
<?php
namespace Laminas\EventManager;
use ArrayAccess;
use function gettype;
use function is_array;
use function is_object;
use function sprintf;
/**
* Representation of an event
*
* Encapsulates the target context and parameters passed, and provides some
* behavior for interacting with the event manager.
*
* @template-covariant TTarget of object|string|null
* @template-covariant TParams of array|ArrayAccess|object
* @implements EventInterface<TTarget, TParams>
*/
class Event implements EventInterface
{
/** @var string|null Event name */
protected $name;
/**
* @var object|string|null The event target
* @psalm-var TTarget
*/
protected $target;
/**
* @var array|ArrayAccess|object The event parameters
* @psalm-var TParams
* @psalm-suppress InvalidPropertyAssignmentValue Empty array _can_ be assigned, but there is no "template type
* default" functionality in Psalm (https://github.com/vimeo/psalm/issues/3048).
*/
protected $params = [];
/** @var bool Whether or not to stop propagation */
protected $stopPropagation = false;
/**
* Constructor
*
* Accept a target and its parameters.
*
* @param string|null $name Event name
* @param string|object|null $target
* @psalm-param TTarget $target
* @param array|ArrayAccess|object|null $params
* @psalm-param TParams|array<empty,empty>|null $params
*/
public function __construct($name = null, $target = null, $params = [])
{
if (null !== $name) {
$this->setName($name);
}
if (null !== $target) {
$this->setTarget($target);
}
if ($params !== null && $params !== []) {
$this->setParams($params);
}
}
/**
* {@inheritDoc}
*/
public function getName()
{
return $this->name;
}
/**
* {@inheritDoc}
*/
public function getTarget()
{
return $this->target;
}
/**
* {@inheritDoc}
*
* @template NewTParams of array|ArrayAccess|object
* @psalm-param NewTParams $params
* @psalm-this-out static&self<TTarget, NewTParams>
* @throws Exception\InvalidArgumentException
*/
public function setParams($params)
{
/** @psalm-suppress DocblockTypeContradiction, RedundantCondition Sanity check to actually enforce docblock. */
if (! is_array($params) && ! is_object($params)) {
throw new Exception\InvalidArgumentException(
sprintf('Event parameters must be an array or object; received "%s"', gettype($params))
);
}
/** @psalm-suppress InvalidPropertyAssignmentValue Pretty sure this is correct after this-out. */
$this->params = $params;
}
/**
* {@inheritDoc}
*/
public function getParams()
{
return $this->params;
}
/**
* {@inheritDoc}
*/
public function getParam($name, $default = null)
{
// Check in params that are arrays or implement array access
if (is_array($this->params) || $this->params instanceof ArrayAccess) {
if (! isset($this->params[$name])) {
return $default;
}
/** @psalm-suppress MixedArrayAccess We've just verified `$this->params` is array-like... */
return $this->params[$name];
}
// Check in normal objects
if (! isset($this->params->{$name})) {
return $default;
}
/** @psalm-suppress MixedPropertyFetch Only object is left over from union. */
return $this->params->{$name};
}
/**
* {@inheritDoc}
*/
public function setName($name)
{
/** @psalm-suppress RedundantCastGivenDocblockType Cast is safety measure in case caller passes junk. */
$this->name = (string) $name;
}
/**
* {@inheritDoc}
*
* @template NewTTarget of object|string|null
* @psalm-param NewTTarget $target
* @psalm-this-out static&self<NewTTarget, TParams>
*/
public function setTarget($target)
{
/** @psalm-suppress InvalidPropertyAssignmentValue Pretty sure this is correct after this-out. */
$this->target = $target;
}
/**
* {@inheritDoc}
*/
public function setParam($name, $value)
{
if (is_array($this->params) || $this->params instanceof ArrayAccess) {
// Arrays or objects implementing array access
/** @psalm-suppress MixedArrayAssignment No way to extend existing array template. */
$this->params[$name] = $value;
return;
}
// Objects
$this->params->{$name} = $value;
}
/**
* {@inheritDoc}
*/
public function stopPropagation($flag = true)
{
/** @psalm-suppress RedundantCastGivenDocblockType Cast is safety measure in case caller passes junk. */
$this->stopPropagation = (bool) $flag;
}
/**
* {@inheritDoc}
*/
public function propagationIsStopped()
{
return $this->stopPropagation;
}
}
|
