1	<?php
2
3	declare(strict_types=1);
4
5	namespace Celema\Router;
6
7	/** @internal */
8	trait AddsBeforeAfter
9	{
10	/** @var list<Before> */
11	protected array $beforeHandlers = [];
12
13	/** @var list<After> */
14	protected array $afterHandlers = [];
15
16	/** @psalm-api */
17	public function before(Before $beforeHandler): static
18	{
19	$this->beforeHandlers = $this->mergeBeforeHandlers([$beforeHandler]);
20
21	return $this;
22	}
23
24	/** @return list<Before> */
25	public function beforeHandlers(): array
26	{
27	return $this->beforeHandlers;
28	}
29
30	/** @psalm-api */
31	public function after(After $afterHandler): static
32	{
33	$this->afterHandlers = $this->mergeAfterHandlers([$afterHandler]);
34
35	return $this;
36	}
37
38	/** @return list<After> */
39	public function afterHandlers(): array
40	{
41	return $this->afterHandlers;
42	}
43
44	/**
45	* @param list<Before> $beforeHandlers
46	* @return list<Before>
47	*/
48	protected function mergeBeforeHandlers(array $beforeHandlers): array
49	{
50	return $this->doMergeBeforeHandlers($this->beforeHandlers, $beforeHandlers);
51	}
52
53	/**
54	* @param list<After> $afterHandlers
55	* @return list<After>
56	*/
57	protected function mergeAfterHandlers(array $afterHandlers): array
58	{
59	return $this->doMergeAfterHandlers($this->afterHandlers, $afterHandlers);
60	}
61
62	/**
63	* @param list<Before> $handlers
64	* @param list<Before> $newHandlers
65	* @return list<Before>
66	*/
67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}
91
92	/**
93	* @param list<After> $handlers
94	* @param list<After> $newHandlers
95	* @return list<After>
96	*/
97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}
121	}

---

Paths

Below are the source code lines that represent each code path as identified by Xdebug. Please note a path is not necessarily coterminous with a line, a line may contain multiple paths and therefore show up more than once. Please also be aware that some paths may include implicit rather than explicit branches, e.g. an if statement always has an else as part of its logical flow even if you didn't write one.

AddsBeforeAfter->after

31	public function after(After $afterHandler): static
32	{
33	$this->afterHandlers = $this->mergeAfterHandlers([$afterHandler]);
34
35	return $this;
36	}

AddsBeforeAfter->afterHandlers

41	return $this->afterHandlers;
42	}

AddsBeforeAfter->before

17	public function before(Before $beforeHandler): static
18	{
19	$this->beforeHandlers = $this->mergeBeforeHandlers([$beforeHandler]);
20
21	return $this;
22	}

AddsBeforeAfter->beforeHandlers

27	return $this->beforeHandlers;
28	}

AddsBeforeAfter->doMergeAfterHandlers

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
104	if (!$replaced && $h->replace($handler)) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

97	protected function doMergeAfterHandlers(array $handlers, array $newHandlers): array
98	{
99	foreach ($newHandlers as $handler) {
99	foreach ($newHandlers as $handler) {
100	$replaced = false;
101	$result = [];
102
103	foreach ($handlers as $h) {
104	if (!$replaced && $h->replace($handler)) {
105	$replaced = true;
106	$result[] = $handler;
107	} else {
108	$result[] = $h;
109	}
110	}
111
112	$handlers = $result;
113
114	if (!$replaced) {
115	$handlers[] = $handler;
116	}
117	}
118
119	return $handlers;
120	}

AddsBeforeAfter->doMergeBeforeHandlers

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
74	if (!$replaced && $h->replace($handler)) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

67	protected function doMergeBeforeHandlers(array $handlers, array $newHandlers): array
68	{
69	foreach ($newHandlers as $handler) {
69	foreach ($newHandlers as $handler) {
70	$replaced = false;
71	$result = [];
72
73	foreach ($handlers as $h) {
74	if (!$replaced && $h->replace($handler)) {
75	$replaced = true;
76	$result[] = $handler;
77	} else {
78	$result[] = $h;
79	}
80	}
81
82	$handlers = $result;
83
84	if (!$replaced) {
85	$handlers[] = $handler;
86	}
87	}
88
89	return $handlers;
90	}

AddsBeforeAfter->mergeAfterHandlers

57	protected function mergeAfterHandlers(array $afterHandlers): array
58	{
59	return $this->doMergeAfterHandlers($this->afterHandlers, $afterHandlers);
60	}

AddsBeforeAfter->mergeBeforeHandlers

48	protected function mergeBeforeHandlers(array $beforeHandlers): array
49	{
50	return $this->doMergeBeforeHandlers($this->beforeHandlers, $beforeHandlers);
51	}

Group->addAfterHandler

31	public function after(After $afterHandler): static
32	{
33	$this->afterHandlers = $this->mergeAfterHandlers([$afterHandler]);
34
35	return $this;
36	}

Group->addBeforeHandler

17	public function before(Before $beforeHandler): static
18	{
19	$this->beforeHandlers = $this->mergeBeforeHandlers([$beforeHandler]);
20
21	return $this;
22	}