|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
/** |
|
4
|
|
|
* provides type inference and auto-completion for magic static methods of Assert. |
|
5
|
|
|
*/ |
|
6
|
|
|
|
|
7
|
|
|
namespace Webmozart\Assert; |
|
8
|
|
|
|
|
9
|
|
|
use ArrayAccess; |
|
10
|
|
|
use Closure; |
|
11
|
|
|
use Countable; |
|
12
|
|
|
use InvalidArgumentException; |
|
13
|
|
|
use Throwable; |
|
14
|
|
|
|
|
15
|
|
|
/** |
|
16
|
|
|
* This trait aids static analysis tooling in introspecting assertion magic methods. |
|
17
|
|
|
* Do not use this trait directly: it will change, and is not designed for reuse. |
|
18
|
|
|
*/ |
|
19
|
|
|
trait Mixin |
|
20
|
|
|
{ |
|
21
|
|
|
/** |
|
22
|
|
|
* @psalm-pure |
|
23
|
|
|
* @psalm-assert string|null $value |
|
24
|
|
|
* |
|
25
|
|
|
* @param mixed $value |
|
26
|
|
|
* @param string $message |
|
27
|
|
|
* |
|
28
|
|
|
* @throws InvalidArgumentException |
|
29
|
|
|
* @return void |
|
30
|
|
|
*/ |
|
31
|
|
|
public static function nullOrString($value, $message = '') |
|
32
|
|
|
{ |
|
33
|
|
|
static::__callStatic('nullOrString', [$value, $message]); |
|
34
|
|
|
} |
|
35
|
|
|
|
|
36
|
|
|
/** |
|
37
|
|
|
* @psalm-pure |
|
38
|
|
|
* @psalm-assert iterable<string> $value |
|
39
|
|
|
* |
|
40
|
|
|
* @param mixed $value |
|
41
|
|
|
* @param string $message |
|
42
|
|
|
* |
|
43
|
|
|
* @throws InvalidArgumentException |
|
44
|
|
|
* @return void |
|
45
|
|
|
*/ |
|
46
|
|
|
public static function allString($value, $message = '') |
|
47
|
|
|
{ |
|
48
|
|
|
static::__callStatic('allString', [$value, $message]); |
|
49
|
|
|
} |
|
50
|
|
|
|
|
51
|
|
|
/** |
|
52
|
|
|
* @psalm-pure |
|
53
|
|
|
* @psalm-assert non-empty-string|null $value |
|
54
|
|
|
* |
|
55
|
|
|
* @param mixed $value |
|
56
|
|
|
* @param string $message |
|
57
|
|
|
* |
|
58
|
|
|
* @throws InvalidArgumentException |
|
59
|
|
|
* @return void |
|
60
|
|
|
*/ |
|
61
|
|
|
public static function nullOrStringNotEmpty($value, $message = '') |
|
62
|
|
|
{ |
|
63
|
|
|
static::__callStatic('nullOrStringNotEmpty', [$value, $message]); |
|
64
|
|
|
} |
|
65
|
|
|
|
|
66
|
|
|
/** |
|
67
|
|
|
* @psalm-pure |
|
68
|
|
|
* @psalm-assert iterable<non-empty-string> $value |
|
69
|
|
|
* |
|
70
|
|
|
* @param mixed $value |
|
71
|
|
|
* @param string $message |
|
72
|
|
|
* |
|
73
|
|
|
* @throws InvalidArgumentException |
|
74
|
|
|
* @return void |
|
75
|
|
|
*/ |
|
76
|
|
|
public static function allStringNotEmpty($value, $message = '') |
|
77
|
|
|
{ |
|
78
|
|
|
static::__callStatic('allStringNotEmpty', [$value, $message]); |
|
79
|
|
|
} |
|
80
|
|
|
|
|
81
|
|
|
/** |
|
82
|
|
|
* @psalm-pure |
|
83
|
|
|
* @psalm-assert int|null $value |
|
84
|
|
|
* |
|
85
|
|
|
* @param mixed $value |
|
86
|
|
|
* @param string $message |
|
87
|
|
|
* |
|
88
|
|
|
* @throws InvalidArgumentException |
|
89
|
|
|
* @return void |
|
90
|
|
|
*/ |
|
91
|
|
|
public static function nullOrInteger($value, $message = '') |
|
92
|
|
|
{ |
|
93
|
|
|
static::__callStatic('nullOrInteger', [$value, $message]); |
|
94
|
|
|
} |
|
95
|
|
|
|
|
96
|
|
|
/** |
|
97
|
|
|
* @psalm-pure |
|
98
|
|
|
* @psalm-assert iterable<int> $value |
|
99
|
|
|
* |
|
100
|
|
|
* @param mixed $value |
|
101
|
|
|
* @param string $message |
|
102
|
|
|
* |
|
103
|
|
|
* @throws InvalidArgumentException |
|
104
|
|
|
* @return void |
|
105
|
|
|
*/ |
|
106
|
|
|
public static function allInteger($value, $message = '') |
|
107
|
|
|
{ |
|
108
|
|
|
static::__callStatic('allInteger', [$value, $message]); |
|
109
|
|
|
} |
|
110
|
|
|
|
|
111
|
|
|
/** |
|
112
|
|
|
* @psalm-pure |
|
113
|
|
|
* @psalm-assert numeric|null $value |
|
114
|
|
|
* |
|
115
|
|
|
* @param mixed $value |
|
116
|
|
|
* @param string $message |
|
117
|
|
|
* |
|
118
|
|
|
* @throws InvalidArgumentException |
|
119
|
|
|
* @return void |
|
120
|
|
|
*/ |
|
121
|
|
|
public static function nullOrIntegerish($value, $message = '') |
|
122
|
|
|
{ |
|
123
|
|
|
static::__callStatic('nullOrIntegerish', [$value, $message]); |
|
124
|
|
|
} |
|
125
|
|
|
|
|
126
|
|
|
/** |
|
127
|
|
|
* @psalm-pure |
|
128
|
|
|
* @psalm-assert iterable<numeric> $value |
|
129
|
|
|
* |
|
130
|
|
|
* @param mixed $value |
|
131
|
|
|
* @param string $message |
|
132
|
|
|
* |
|
133
|
|
|
* @throws InvalidArgumentException |
|
134
|
|
|
* @return void |
|
135
|
|
|
*/ |
|
136
|
|
|
public static function allIntegerish($value, $message = '') |
|
137
|
|
|
{ |
|
138
|
|
|
static::__callStatic('allIntegerish', [$value, $message]); |
|
139
|
|
|
} |
|
140
|
|
|
|
|
141
|
|
|
/** |
|
142
|
|
|
* @psalm-pure |
|
143
|
|
|
* @psalm-assert positive-int|null $value |
|
144
|
|
|
* |
|
145
|
|
|
* @param mixed $value |
|
146
|
|
|
* @param string $message |
|
147
|
|
|
* |
|
148
|
|
|
* @throws InvalidArgumentException |
|
149
|
|
|
* @return void |
|
150
|
|
|
*/ |
|
151
|
|
|
public static function nullOrPositiveInteger($value, $message = '') |
|
152
|
|
|
{ |
|
153
|
|
|
static::__callStatic('nullOrPositiveInteger', [$value, $message]); |
|
154
|
|
|
} |
|
155
|
|
|
|
|
156
|
|
|
/** |
|
157
|
|
|
* @psalm-pure |
|
158
|
|
|
* @psalm-assert iterable<positive-int> $value |
|
159
|
|
|
* |
|
160
|
|
|
* @param mixed $value |
|
161
|
|
|
* @param string $message |
|
162
|
|
|
* |
|
163
|
|
|
* @throws InvalidArgumentException |
|
164
|
|
|
* @return void |
|
165
|
|
|
*/ |
|
166
|
|
|
public static function allPositiveInteger($value, $message = '') |
|
167
|
|
|
{ |
|
168
|
|
|
static::__callStatic('allPositiveInteger', [$value, $message]); |
|
169
|
|
|
} |
|
170
|
|
|
|
|
171
|
|
|
/** |
|
172
|
|
|
* @psalm-pure |
|
173
|
|
|
* @psalm-assert float|null $value |
|
174
|
|
|
* |
|
175
|
|
|
* @param mixed $value |
|
176
|
|
|
* @param string $message |
|
177
|
|
|
* |
|
178
|
|
|
* @throws InvalidArgumentException |
|
179
|
|
|
* @return void |
|
180
|
|
|
*/ |
|
181
|
|
|
public static function nullOrFloat($value, $message = '') |
|
182
|
|
|
{ |
|
183
|
|
|
static::__callStatic('nullOrFloat', [$value, $message]); |
|
184
|
|
|
} |
|
185
|
|
|
|
|
186
|
|
|
/** |
|
187
|
|
|
* @psalm-pure |
|
188
|
|
|
* @psalm-assert iterable<float> $value |
|
189
|
|
|
* |
|
190
|
|
|
* @param mixed $value |
|
191
|
|
|
* @param string $message |
|
192
|
|
|
* |
|
193
|
|
|
* @throws InvalidArgumentException |
|
194
|
|
|
* @return void |
|
195
|
|
|
*/ |
|
196
|
|
|
public static function allFloat($value, $message = '') |
|
197
|
|
|
{ |
|
198
|
|
|
static::__callStatic('allFloat', [$value, $message]); |
|
199
|
|
|
} |
|
200
|
|
|
|
|
201
|
|
|
/** |
|
202
|
|
|
* @psalm-pure |
|
203
|
|
|
* @psalm-assert numeric|null $value |
|
204
|
|
|
* |
|
205
|
|
|
* @param mixed $value |
|
206
|
|
|
* @param string $message |
|
207
|
|
|
* |
|
208
|
|
|
* @throws InvalidArgumentException |
|
209
|
|
|
* @return void |
|
210
|
|
|
*/ |
|
211
|
|
|
public static function nullOrNumeric($value, $message = '') |
|
212
|
|
|
{ |
|
213
|
|
|
static::__callStatic('nullOrNumeric', [$value, $message]); |
|
214
|
|
|
} |
|
215
|
|
|
|
|
216
|
|
|
/** |
|
217
|
|
|
* @psalm-pure |
|
218
|
|
|
* @psalm-assert iterable<numeric> $value |
|
219
|
|
|
* |
|
220
|
|
|
* @param mixed $value |
|
221
|
|
|
* @param string $message |
|
222
|
|
|
* |
|
223
|
|
|
* @throws InvalidArgumentException |
|
224
|
|
|
* @return void |
|
225
|
|
|
*/ |
|
226
|
|
|
public static function allNumeric($value, $message = '') |
|
227
|
|
|
{ |
|
228
|
|
|
static::__callStatic('allNumeric', [$value, $message]); |
|
229
|
|
|
} |
|
230
|
|
|
|
|
231
|
|
|
/** |
|
232
|
|
|
* @psalm-pure |
|
233
|
|
|
* @psalm-assert positive-int|0|null $value |
|
234
|
|
|
* |
|
235
|
|
|
* @param mixed $value |
|
236
|
|
|
* @param string $message |
|
237
|
|
|
* |
|
238
|
|
|
* @throws InvalidArgumentException |
|
239
|
|
|
* @return void |
|
240
|
|
|
*/ |
|
241
|
|
|
public static function nullOrNatural($value, $message = '') |
|
242
|
|
|
{ |
|
243
|
|
|
static::__callStatic('nullOrNatural', [$value, $message]); |
|
244
|
|
|
} |
|
245
|
|
|
|
|
246
|
|
|
/** |
|
247
|
|
|
* @psalm-pure |
|
248
|
|
|
* @psalm-assert iterable<positive-int|0> $value |
|
249
|
|
|
* |
|
250
|
|
|
* @param mixed $value |
|
251
|
|
|
* @param string $message |
|
252
|
|
|
* |
|
253
|
|
|
* @throws InvalidArgumentException |
|
254
|
|
|
* @return void |
|
255
|
|
|
*/ |
|
256
|
|
|
public static function allNatural($value, $message = '') |
|
257
|
|
|
{ |
|
258
|
|
|
static::__callStatic('allNatural', [$value, $message]); |
|
259
|
|
|
} |
|
260
|
|
|
|
|
261
|
|
|
/** |
|
262
|
|
|
* @psalm-pure |
|
263
|
|
|
* @psalm-assert bool|null $value |
|
264
|
|
|
* |
|
265
|
|
|
* @param mixed $value |
|
266
|
|
|
* @param string $message |
|
267
|
|
|
* |
|
268
|
|
|
* @throws InvalidArgumentException |
|
269
|
|
|
* @return void |
|
270
|
|
|
*/ |
|
271
|
|
|
public static function nullOrBoolean($value, $message = '') |
|
272
|
|
|
{ |
|
273
|
|
|
static::__callStatic('nullOrBoolean', [$value, $message]); |
|
274
|
|
|
} |
|
275
|
|
|
|
|
276
|
|
|
/** |
|
277
|
|
|
* @psalm-pure |
|
278
|
|
|
* @psalm-assert iterable<bool> $value |
|
279
|
|
|
* |
|
280
|
|
|
* @param mixed $value |
|
281
|
|
|
* @param string $message |
|
282
|
|
|
* |
|
283
|
|
|
* @throws InvalidArgumentException |
|
284
|
|
|
* @return void |
|
285
|
|
|
*/ |
|
286
|
|
|
public static function allBoolean($value, $message = '') |
|
287
|
|
|
{ |
|
288
|
|
|
static::__callStatic('allBoolean', [$value, $message]); |
|
289
|
|
|
} |
|
290
|
|
|
|
|
291
|
|
|
/** |
|
292
|
|
|
* @psalm-pure |
|
293
|
|
|
* @psalm-assert scalar|null $value |
|
294
|
|
|
* |
|
295
|
|
|
* @param mixed $value |
|
296
|
|
|
* @param string $message |
|
297
|
|
|
* |
|
298
|
|
|
* @throws InvalidArgumentException |
|
299
|
|
|
* @return void |
|
300
|
|
|
*/ |
|
301
|
|
|
public static function nullOrScalar($value, $message = '') |
|
302
|
|
|
{ |
|
303
|
|
|
static::__callStatic('nullOrScalar', [$value, $message]); |
|
304
|
|
|
} |
|
305
|
|
|
|
|
306
|
|
|
/** |
|
307
|
|
|
* @psalm-pure |
|
308
|
|
|
* @psalm-assert iterable<scalar> $value |
|
309
|
|
|
* |
|
310
|
|
|
* @param mixed $value |
|
311
|
|
|
* @param string $message |
|
312
|
|
|
* |
|
313
|
|
|
* @throws InvalidArgumentException |
|
314
|
|
|
* @return void |
|
315
|
|
|
*/ |
|
316
|
|
|
public static function allScalar($value, $message = '') |
|
317
|
|
|
{ |
|
318
|
|
|
static::__callStatic('allScalar', [$value, $message]); |
|
319
|
|
|
} |
|
320
|
|
|
|
|
321
|
|
|
/** |
|
322
|
|
|
* @psalm-pure |
|
323
|
|
|
* @psalm-assert object|null $value |
|
324
|
|
|
* |
|
325
|
|
|
* @param mixed $value |
|
326
|
|
|
* @param string $message |
|
327
|
|
|
* |
|
328
|
|
|
* @throws InvalidArgumentException |
|
329
|
|
|
* @return void |
|
330
|
|
|
*/ |
|
331
|
|
|
public static function nullOrObject($value, $message = '') |
|
332
|
|
|
{ |
|
333
|
|
|
static::__callStatic('nullOrObject', [$value, $message]); |
|
334
|
|
|
} |
|
335
|
|
|
|
|
336
|
|
|
/** |
|
337
|
|
|
* @psalm-pure |
|
338
|
|
|
* @psalm-assert iterable<object> $value |
|
339
|
|
|
* |
|
340
|
|
|
* @param mixed $value |
|
341
|
|
|
* @param string $message |
|
342
|
|
|
* |
|
343
|
|
|
* @throws InvalidArgumentException |
|
344
|
|
|
* @return void |
|
345
|
|
|
*/ |
|
346
|
|
|
public static function allObject($value, $message = '') |
|
347
|
|
|
{ |
|
348
|
|
|
static::__callStatic('allObject', [$value, $message]); |
|
349
|
|
|
} |
|
350
|
|
|
|
|
351
|
|
|
/** |
|
352
|
|
|
* @psalm-pure |
|
353
|
|
|
* @psalm-assert resource|null $value |
|
354
|
|
|
* |
|
355
|
|
|
* @param mixed $value |
|
356
|
|
|
* @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php |
|
357
|
|
|
* @param string $message |
|
358
|
|
|
* |
|
359
|
|
|
* @throws InvalidArgumentException |
|
360
|
|
|
* @return void |
|
361
|
|
|
*/ |
|
362
|
|
|
public static function nullOrResource($value, $type = null, $message = '') |
|
363
|
|
|
{ |
|
364
|
|
|
static::__callStatic('nullOrResource', [$value, $type, $message]); |
|
365
|
|
|
} |
|
366
|
|
|
|
|
367
|
|
|
/** |
|
368
|
|
|
* @psalm-pure |
|
369
|
|
|
* @psalm-assert iterable<resource> $value |
|
370
|
|
|
* |
|
371
|
|
|
* @param mixed $value |
|
372
|
|
|
* @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php |
|
373
|
|
|
* @param string $message |
|
374
|
|
|
* |
|
375
|
|
|
* @throws InvalidArgumentException |
|
376
|
|
|
* @return void |
|
377
|
|
|
*/ |
|
378
|
|
|
public static function allResource($value, $type = null, $message = '') |
|
379
|
|
|
{ |
|
380
|
|
|
static::__callStatic('allResource', [$value, $type, $message]); |
|
381
|
|
|
} |
|
382
|
|
|
|
|
383
|
|
|
/** |
|
384
|
|
|
* @psalm-pure |
|
385
|
|
|
* @psalm-assert callable|null $value |
|
386
|
|
|
* |
|
387
|
|
|
* @param mixed $value |
|
388
|
|
|
* @param string $message |
|
389
|
|
|
* |
|
390
|
|
|
* @throws InvalidArgumentException |
|
391
|
|
|
* @return void |
|
392
|
|
|
*/ |
|
393
|
|
|
public static function nullOrIsCallable($value, $message = '') |
|
394
|
|
|
{ |
|
395
|
|
|
static::__callStatic('nullOrIsCallable', [$value, $message]); |
|
396
|
|
|
} |
|
397
|
|
|
|
|
398
|
|
|
/** |
|
399
|
|
|
* @psalm-pure |
|
400
|
|
|
* @psalm-assert iterable<callable> $value |
|
401
|
|
|
* |
|
402
|
|
|
* @param mixed $value |
|
403
|
|
|
* @param string $message |
|
404
|
|
|
* |
|
405
|
|
|
* @throws InvalidArgumentException |
|
406
|
|
|
* @return void |
|
407
|
|
|
*/ |
|
408
|
|
|
public static function allIsCallable($value, $message = '') |
|
409
|
|
|
{ |
|
410
|
|
|
static::__callStatic('allIsCallable', [$value, $message]); |
|
411
|
|
|
} |
|
412
|
|
|
|
|
413
|
|
|
/** |
|
414
|
|
|
* @psalm-pure |
|
415
|
|
|
* @psalm-assert array|null $value |
|
416
|
|
|
* |
|
417
|
|
|
* @param mixed $value |
|
418
|
|
|
* @param string $message |
|
419
|
|
|
* |
|
420
|
|
|
* @throws InvalidArgumentException |
|
421
|
|
|
* @return void |
|
422
|
|
|
*/ |
|
423
|
|
|
public static function nullOrIsArray($value, $message = '') |
|
424
|
|
|
{ |
|
425
|
|
|
static::__callStatic('nullOrIsArray', [$value, $message]); |
|
426
|
|
|
} |
|
427
|
|
|
|
|
428
|
|
|
/** |
|
429
|
|
|
* @psalm-pure |
|
430
|
|
|
* @psalm-assert iterable<array> $value |
|
431
|
|
|
* |
|
432
|
|
|
* @param mixed $value |
|
433
|
|
|
* @param string $message |
|
434
|
|
|
* |
|
435
|
|
|
* @throws InvalidArgumentException |
|
436
|
|
|
* @return void |
|
437
|
|
|
*/ |
|
438
|
|
|
public static function allIsArray($value, $message = '') |
|
439
|
|
|
{ |
|
440
|
|
|
static::__callStatic('allIsArray', [$value, $message]); |
|
441
|
|
|
} |
|
442
|
|
|
|
|
443
|
|
|
/** |
|
444
|
|
|
* @psalm-pure |
|
445
|
|
|
* @psalm-assert iterable|null $value |
|
446
|
|
|
* |
|
447
|
|
|
* @deprecated use "isIterable" or "isInstanceOf" instead |
|
448
|
|
|
* |
|
449
|
|
|
* @param mixed $value |
|
450
|
|
|
* @param string $message |
|
451
|
|
|
* |
|
452
|
|
|
* @throws InvalidArgumentException |
|
453
|
|
|
* @return void |
|
454
|
|
|
*/ |
|
455
|
|
|
public static function nullOrIsTraversable($value, $message = '') |
|
456
|
|
|
{ |
|
457
|
|
|
static::__callStatic('nullOrIsTraversable', [$value, $message]); |
|
458
|
|
|
} |
|
459
|
|
|
|
|
460
|
|
|
/** |
|
461
|
|
|
* @psalm-pure |
|
462
|
|
|
* @psalm-assert iterable<iterable> $value |
|
463
|
|
|
* |
|
464
|
|
|
* @deprecated use "isIterable" or "isInstanceOf" instead |
|
465
|
|
|
* |
|
466
|
|
|
* @param mixed $value |
|
467
|
|
|
* @param string $message |
|
468
|
|
|
* |
|
469
|
|
|
* @throws InvalidArgumentException |
|
470
|
|
|
* @return void |
|
471
|
|
|
*/ |
|
472
|
|
|
public static function allIsTraversable($value, $message = '') |
|
473
|
|
|
{ |
|
474
|
|
|
static::__callStatic('allIsTraversable', [$value, $message]); |
|
475
|
|
|
} |
|
476
|
|
|
|
|
477
|
|
|
/** |
|
478
|
|
|
* @psalm-pure |
|
479
|
|
|
* @psalm-assert array|ArrayAccess|null $value |
|
480
|
|
|
* |
|
481
|
|
|
* @param mixed $value |
|
482
|
|
|
* @param string $message |
|
483
|
|
|
* |
|
484
|
|
|
* @throws InvalidArgumentException |
|
485
|
|
|
* @return void |
|
486
|
|
|
*/ |
|
487
|
|
|
public static function nullOrIsArrayAccessible($value, $message = '') |
|
488
|
|
|
{ |
|
489
|
|
|
static::__callStatic('nullOrIsArrayAccessible', [$value, $message]); |
|
490
|
|
|
} |
|
491
|
|
|
|
|
492
|
|
|
/** |
|
493
|
|
|
* @psalm-pure |
|
494
|
|
|
* @psalm-assert iterable<array|ArrayAccess> $value |
|
495
|
|
|
* |
|
496
|
|
|
* @param mixed $value |
|
497
|
|
|
* @param string $message |
|
498
|
|
|
* |
|
499
|
|
|
* @throws InvalidArgumentException |
|
500
|
|
|
* @return void |
|
501
|
|
|
*/ |
|
502
|
|
|
public static function allIsArrayAccessible($value, $message = '') |
|
503
|
|
|
{ |
|
504
|
|
|
static::__callStatic('allIsArrayAccessible', [$value, $message]); |
|
505
|
|
|
} |
|
506
|
|
|
|
|
507
|
|
|
/** |
|
508
|
|
|
* @psalm-pure |
|
509
|
|
|
* @psalm-assert countable|null $value |
|
510
|
|
|
* |
|
511
|
|
|
* @param mixed $value |
|
512
|
|
|
* @param string $message |
|
513
|
|
|
* |
|
514
|
|
|
* @throws InvalidArgumentException |
|
515
|
|
|
* @return void |
|
516
|
|
|
*/ |
|
517
|
|
|
public static function nullOrIsCountable($value, $message = '') |
|
518
|
|
|
{ |
|
519
|
|
|
static::__callStatic('nullOrIsCountable', [$value, $message]); |
|
520
|
|
|
} |
|
521
|
|
|
|
|
522
|
|
|
/** |
|
523
|
|
|
* @psalm-pure |
|
524
|
|
|
* @psalm-assert iterable<countable> $value |
|
525
|
|
|
* |
|
526
|
|
|
* @param mixed $value |
|
527
|
|
|
* @param string $message |
|
528
|
|
|
* |
|
529
|
|
|
* @throws InvalidArgumentException |
|
530
|
|
|
* @return void |
|
531
|
|
|
*/ |
|
532
|
|
|
public static function allIsCountable($value, $message = '') |
|
533
|
|
|
{ |
|
534
|
|
|
static::__callStatic('allIsCountable', [$value, $message]); |
|
535
|
|
|
} |
|
536
|
|
|
|
|
537
|
|
|
/** |
|
538
|
|
|
* @psalm-pure |
|
539
|
|
|
* @psalm-assert iterable|null $value |
|
540
|
|
|
* |
|
541
|
|
|
* @param mixed $value |
|
542
|
|
|
* @param string $message |
|
543
|
|
|
* |
|
544
|
|
|
* @throws InvalidArgumentException |
|
545
|
|
|
* @return void |
|
546
|
|
|
*/ |
|
547
|
|
|
public static function nullOrIsIterable($value, $message = '') |
|
548
|
|
|
{ |
|
549
|
|
|
static::__callStatic('nullOrIsIterable', [$value, $message]); |
|
550
|
|
|
} |
|
551
|
|
|
|
|
552
|
|
|
/** |
|
553
|
|
|
* @psalm-pure |
|
554
|
|
|
* @psalm-assert iterable<iterable> $value |
|
555
|
|
|
* |
|
556
|
|
|
* @param mixed $value |
|
557
|
|
|
* @param string $message |
|
558
|
|
|
* |
|
559
|
|
|
* @throws InvalidArgumentException |
|
560
|
|
|
* @return void |
|
561
|
|
|
*/ |
|
562
|
|
|
public static function allIsIterable($value, $message = '') |
|
563
|
|
|
{ |
|
564
|
|
|
static::__callStatic('allIsIterable', [$value, $message]); |
|
565
|
|
|
} |
|
566
|
|
|
|
|
567
|
|
|
/** |
|
568
|
|
|
* @psalm-pure |
|
569
|
|
|
* @psalm-template ExpectedType of object |
|
570
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
571
|
|
|
* @psalm-assert ExpectedType|null $value |
|
572
|
|
|
* |
|
573
|
|
|
* @param mixed $value |
|
574
|
|
|
* @param string|object $class |
|
575
|
|
|
* @param string $message |
|
576
|
|
|
* |
|
577
|
|
|
* @throws InvalidArgumentException |
|
578
|
|
|
* @return void |
|
579
|
|
|
*/ |
|
580
|
|
|
public static function nullOrIsInstanceOf($value, $class, $message = '') |
|
581
|
|
|
{ |
|
582
|
|
|
static::__callStatic('nullOrIsInstanceOf', [$value, $class, $message]); |
|
583
|
|
|
} |
|
584
|
|
|
|
|
585
|
|
|
/** |
|
586
|
|
|
* @psalm-pure |
|
587
|
|
|
* @psalm-template ExpectedType of object |
|
588
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
589
|
|
|
* @psalm-assert iterable<ExpectedType> $value |
|
590
|
|
|
* |
|
591
|
|
|
* @param mixed $value |
|
592
|
|
|
* @param string|object $class |
|
593
|
|
|
* @param string $message |
|
594
|
|
|
* |
|
595
|
|
|
* @throws InvalidArgumentException |
|
596
|
|
|
* @return void |
|
597
|
|
|
*/ |
|
598
|
|
|
public static function allIsInstanceOf($value, $class, $message = '') |
|
599
|
|
|
{ |
|
600
|
|
|
static::__callStatic('allIsInstanceOf', [$value, $class, $message]); |
|
601
|
|
|
} |
|
602
|
|
|
|
|
603
|
|
|
/** |
|
604
|
|
|
* @psalm-pure |
|
605
|
|
|
* @psalm-template ExpectedType of object |
|
606
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
607
|
|
|
* |
|
608
|
|
|
* @param mixed $value |
|
609
|
|
|
* @param string|object $class |
|
610
|
|
|
* @param string $message |
|
611
|
|
|
* |
|
612
|
|
|
* @throws InvalidArgumentException |
|
613
|
|
|
* @return void |
|
614
|
|
|
*/ |
|
615
|
|
|
public static function nullOrNotInstanceOf($value, $class, $message = '') |
|
616
|
|
|
{ |
|
617
|
|
|
static::__callStatic('nullOrNotInstanceOf', [$value, $class, $message]); |
|
618
|
|
|
} |
|
619
|
|
|
|
|
620
|
|
|
/** |
|
621
|
|
|
* @psalm-pure |
|
622
|
|
|
* @psalm-template ExpectedType of object |
|
623
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
624
|
|
|
* |
|
625
|
|
|
* @param mixed $value |
|
626
|
|
|
* @param string|object $class |
|
627
|
|
|
* @param string $message |
|
628
|
|
|
* |
|
629
|
|
|
* @throws InvalidArgumentException |
|
630
|
|
|
* @return void |
|
631
|
|
|
*/ |
|
632
|
|
|
public static function allNotInstanceOf($value, $class, $message = '') |
|
633
|
|
|
{ |
|
634
|
|
|
static::__callStatic('allNotInstanceOf', [$value, $class, $message]); |
|
635
|
|
|
} |
|
636
|
|
|
|
|
637
|
|
|
/** |
|
638
|
|
|
* @psalm-pure |
|
639
|
|
|
* @psalm-param array<class-string> $classes |
|
640
|
|
|
* |
|
641
|
|
|
* @param mixed $value |
|
642
|
|
|
* @param array<object|string> $classes |
|
643
|
|
|
* @param string $message |
|
644
|
|
|
* |
|
645
|
|
|
* @throws InvalidArgumentException |
|
646
|
|
|
* @return void |
|
647
|
|
|
*/ |
|
648
|
|
|
public static function nullOrIsInstanceOfAny($value, $classes, $message = '') |
|
649
|
|
|
{ |
|
650
|
|
|
static::__callStatic('nullOrIsInstanceOfAny', [$value, $classes, $message]); |
|
651
|
|
|
} |
|
652
|
|
|
|
|
653
|
|
|
/** |
|
654
|
|
|
* @psalm-pure |
|
655
|
|
|
* @psalm-param array<class-string> $classes |
|
656
|
|
|
* |
|
657
|
|
|
* @param mixed $value |
|
658
|
|
|
* @param array<object|string> $classes |
|
659
|
|
|
* @param string $message |
|
660
|
|
|
* |
|
661
|
|
|
* @throws InvalidArgumentException |
|
662
|
|
|
* @return void |
|
663
|
|
|
*/ |
|
664
|
|
|
public static function allIsInstanceOfAny($value, $classes, $message = '') |
|
665
|
|
|
{ |
|
666
|
|
|
static::__callStatic('allIsInstanceOfAny', [$value, $classes, $message]); |
|
667
|
|
|
} |
|
668
|
|
|
|
|
669
|
|
|
/** |
|
670
|
|
|
* @psalm-pure |
|
671
|
|
|
* @psalm-template ExpectedType of object |
|
672
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
673
|
|
|
* @psalm-assert ExpectedType|class-string<ExpectedType>|null $value |
|
674
|
|
|
* |
|
675
|
|
|
* @param object|string|null $value |
|
676
|
|
|
* @param string $class |
|
677
|
|
|
* @param string $message |
|
678
|
|
|
* |
|
679
|
|
|
* @throws InvalidArgumentException |
|
680
|
|
|
* @return void |
|
681
|
|
|
*/ |
|
682
|
|
|
public static function nullOrIsAOf($value, $class, $message = '') |
|
683
|
|
|
{ |
|
684
|
|
|
static::__callStatic('nullOrIsAOf', [$value, $class, $message]); |
|
685
|
|
|
} |
|
686
|
|
|
|
|
687
|
|
|
/** |
|
688
|
|
|
* @psalm-pure |
|
689
|
|
|
* @psalm-template ExpectedType of object |
|
690
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
691
|
|
|
* @psalm-assert iterable<ExpectedType|class-string<ExpectedType>> $value |
|
692
|
|
|
* |
|
693
|
|
|
* @param iterable<object|string> $value |
|
|
|
|
|
|
694
|
|
|
* @param string $class |
|
695
|
|
|
* @param string $message |
|
696
|
|
|
* |
|
697
|
|
|
* @throws InvalidArgumentException |
|
698
|
|
|
* @return void |
|
699
|
|
|
*/ |
|
700
|
|
|
public static function allIsAOf($value, $class, $message = '') |
|
701
|
|
|
{ |
|
702
|
|
|
static::__callStatic('allIsAOf', [$value, $class, $message]); |
|
703
|
|
|
} |
|
704
|
|
|
|
|
705
|
|
|
/** |
|
706
|
|
|
* @psalm-pure |
|
707
|
|
|
* @psalm-template UnexpectedType of object |
|
708
|
|
|
* @psalm-param class-string<UnexpectedType> $class |
|
709
|
|
|
* |
|
710
|
|
|
* @param object|string|null $value |
|
711
|
|
|
* @param string $class |
|
712
|
|
|
* @param string $message |
|
713
|
|
|
* |
|
714
|
|
|
* @throws InvalidArgumentException |
|
715
|
|
|
* @return void |
|
716
|
|
|
*/ |
|
717
|
|
|
public static function nullOrIsNotA($value, $class, $message = '') |
|
718
|
|
|
{ |
|
719
|
|
|
static::__callStatic('nullOrIsNotA', [$value, $class, $message]); |
|
720
|
|
|
} |
|
721
|
|
|
|
|
722
|
|
|
/** |
|
723
|
|
|
* @psalm-pure |
|
724
|
|
|
* @psalm-template UnexpectedType of object |
|
725
|
|
|
* @psalm-param class-string<UnexpectedType> $class |
|
726
|
|
|
* |
|
727
|
|
|
* @param iterable<object|string> $value |
|
|
|
|
|
|
728
|
|
|
* @param string $class |
|
729
|
|
|
* @param string $message |
|
730
|
|
|
* |
|
731
|
|
|
* @throws InvalidArgumentException |
|
732
|
|
|
* @return void |
|
733
|
|
|
*/ |
|
734
|
|
|
public static function allIsNotA($value, $class, $message = '') |
|
735
|
|
|
{ |
|
736
|
|
|
static::__callStatic('allIsNotA', [$value, $class, $message]); |
|
737
|
|
|
} |
|
738
|
|
|
|
|
739
|
|
|
/** |
|
740
|
|
|
* @psalm-pure |
|
741
|
|
|
* @psalm-param array<class-string> $classes |
|
742
|
|
|
* |
|
743
|
|
|
* @param object|string|null $value |
|
744
|
|
|
* @param string[] $classes |
|
745
|
|
|
* @param string $message |
|
746
|
|
|
* |
|
747
|
|
|
* @throws InvalidArgumentException |
|
748
|
|
|
* @return void |
|
749
|
|
|
*/ |
|
750
|
|
|
public static function nullOrIsAnyOf($value, $classes, $message = '') |
|
751
|
|
|
{ |
|
752
|
|
|
static::__callStatic('nullOrIsAnyOf', [$value, $classes, $message]); |
|
753
|
|
|
} |
|
754
|
|
|
|
|
755
|
|
|
/** |
|
756
|
|
|
* @psalm-pure |
|
757
|
|
|
* @psalm-param array<class-string> $classes |
|
758
|
|
|
* |
|
759
|
|
|
* @param iterable<object|string> $value |
|
|
|
|
|
|
760
|
|
|
* @param string[] $classes |
|
761
|
|
|
* @param string $message |
|
762
|
|
|
* |
|
763
|
|
|
* @throws InvalidArgumentException |
|
764
|
|
|
* @return void |
|
765
|
|
|
*/ |
|
766
|
|
|
public static function allIsAnyOf($value, $classes, $message = '') |
|
767
|
|
|
{ |
|
768
|
|
|
static::__callStatic('allIsAnyOf', [$value, $classes, $message]); |
|
769
|
|
|
} |
|
770
|
|
|
|
|
771
|
|
|
/** |
|
772
|
|
|
* @psalm-pure |
|
773
|
|
|
* @psalm-assert empty $value |
|
774
|
|
|
* |
|
775
|
|
|
* @param mixed $value |
|
776
|
|
|
* @param string $message |
|
777
|
|
|
* |
|
778
|
|
|
* @throws InvalidArgumentException |
|
779
|
|
|
* @return void |
|
780
|
|
|
*/ |
|
781
|
|
|
public static function nullOrIsEmpty($value, $message = '') |
|
782
|
|
|
{ |
|
783
|
|
|
static::__callStatic('nullOrIsEmpty', [$value, $message]); |
|
784
|
|
|
} |
|
785
|
|
|
|
|
786
|
|
|
/** |
|
787
|
|
|
* @psalm-pure |
|
788
|
|
|
* @psalm-assert iterable<empty> $value |
|
789
|
|
|
* |
|
790
|
|
|
* @param mixed $value |
|
791
|
|
|
* @param string $message |
|
792
|
|
|
* |
|
793
|
|
|
* @throws InvalidArgumentException |
|
794
|
|
|
* @return void |
|
795
|
|
|
*/ |
|
796
|
|
|
public static function allIsEmpty($value, $message = '') |
|
797
|
|
|
{ |
|
798
|
|
|
static::__callStatic('allIsEmpty', [$value, $message]); |
|
799
|
|
|
} |
|
800
|
|
|
|
|
801
|
|
|
/** |
|
802
|
|
|
* @psalm-pure |
|
803
|
|
|
* |
|
804
|
|
|
* @param mixed $value |
|
805
|
|
|
* @param string $message |
|
806
|
|
|
* |
|
807
|
|
|
* @throws InvalidArgumentException |
|
808
|
|
|
* @return void |
|
809
|
|
|
*/ |
|
810
|
|
|
public static function nullOrNotEmpty($value, $message = '') |
|
811
|
|
|
{ |
|
812
|
|
|
static::__callStatic('nullOrNotEmpty', [$value, $message]); |
|
813
|
|
|
} |
|
814
|
|
|
|
|
815
|
|
|
/** |
|
816
|
|
|
* @psalm-pure |
|
817
|
|
|
* |
|
818
|
|
|
* @param mixed $value |
|
819
|
|
|
* @param string $message |
|
820
|
|
|
* |
|
821
|
|
|
* @throws InvalidArgumentException |
|
822
|
|
|
* @return void |
|
823
|
|
|
*/ |
|
824
|
|
|
public static function allNotEmpty($value, $message = '') |
|
825
|
|
|
{ |
|
826
|
|
|
static::__callStatic('allNotEmpty', [$value, $message]); |
|
827
|
|
|
} |
|
828
|
|
|
|
|
829
|
|
|
/** |
|
830
|
|
|
* @psalm-pure |
|
831
|
|
|
* @psalm-assert iterable<null> $value |
|
832
|
|
|
* |
|
833
|
|
|
* @param mixed $value |
|
834
|
|
|
* @param string $message |
|
835
|
|
|
* |
|
836
|
|
|
* @throws InvalidArgumentException |
|
837
|
|
|
* @return void |
|
838
|
|
|
*/ |
|
839
|
|
|
public static function allNull($value, $message = '') |
|
840
|
|
|
{ |
|
841
|
|
|
static::__callStatic('allNull', [$value, $message]); |
|
842
|
|
|
} |
|
843
|
|
|
|
|
844
|
|
|
/** |
|
845
|
|
|
* @psalm-pure |
|
846
|
|
|
* |
|
847
|
|
|
* @param mixed $value |
|
848
|
|
|
* @param string $message |
|
849
|
|
|
* |
|
850
|
|
|
* @throws InvalidArgumentException |
|
851
|
|
|
* @return void |
|
852
|
|
|
*/ |
|
853
|
|
|
public static function allNotNull($value, $message = '') |
|
854
|
|
|
{ |
|
855
|
|
|
static::__callStatic('allNotNull', [$value, $message]); |
|
856
|
|
|
} |
|
857
|
|
|
|
|
858
|
|
|
/** |
|
859
|
|
|
* @psalm-pure |
|
860
|
|
|
* @psalm-assert true|null $value |
|
861
|
|
|
* |
|
862
|
|
|
* @param mixed $value |
|
863
|
|
|
* @param string $message |
|
864
|
|
|
* |
|
865
|
|
|
* @throws InvalidArgumentException |
|
866
|
|
|
* @return void |
|
867
|
|
|
*/ |
|
868
|
|
|
public static function nullOrTrue($value, $message = '') |
|
869
|
|
|
{ |
|
870
|
|
|
static::__callStatic('nullOrTrue', [$value, $message]); |
|
871
|
|
|
} |
|
872
|
|
|
|
|
873
|
|
|
/** |
|
874
|
|
|
* @psalm-pure |
|
875
|
|
|
* @psalm-assert iterable<true> $value |
|
876
|
|
|
* |
|
877
|
|
|
* @param mixed $value |
|
878
|
|
|
* @param string $message |
|
879
|
|
|
* |
|
880
|
|
|
* @throws InvalidArgumentException |
|
881
|
|
|
* @return void |
|
882
|
|
|
*/ |
|
883
|
|
|
public static function allTrue($value, $message = '') |
|
884
|
|
|
{ |
|
885
|
|
|
static::__callStatic('allTrue', [$value, $message]); |
|
886
|
|
|
} |
|
887
|
|
|
|
|
888
|
|
|
/** |
|
889
|
|
|
* @psalm-pure |
|
890
|
|
|
* @psalm-assert false|null $value |
|
891
|
|
|
* |
|
892
|
|
|
* @param mixed $value |
|
893
|
|
|
* @param string $message |
|
894
|
|
|
* |
|
895
|
|
|
* @throws InvalidArgumentException |
|
896
|
|
|
* @return void |
|
897
|
|
|
*/ |
|
898
|
|
|
public static function nullOrFalse($value, $message = '') |
|
899
|
|
|
{ |
|
900
|
|
|
static::__callStatic('nullOrFalse', [$value, $message]); |
|
901
|
|
|
} |
|
902
|
|
|
|
|
903
|
|
|
/** |
|
904
|
|
|
* @psalm-pure |
|
905
|
|
|
* @psalm-assert iterable<false> $value |
|
906
|
|
|
* |
|
907
|
|
|
* @param mixed $value |
|
908
|
|
|
* @param string $message |
|
909
|
|
|
* |
|
910
|
|
|
* @throws InvalidArgumentException |
|
911
|
|
|
* @return void |
|
912
|
|
|
*/ |
|
913
|
|
|
public static function allFalse($value, $message = '') |
|
914
|
|
|
{ |
|
915
|
|
|
static::__callStatic('allFalse', [$value, $message]); |
|
916
|
|
|
} |
|
917
|
|
|
|
|
918
|
|
|
/** |
|
919
|
|
|
* @psalm-pure |
|
920
|
|
|
* |
|
921
|
|
|
* @param mixed $value |
|
922
|
|
|
* @param string $message |
|
923
|
|
|
* |
|
924
|
|
|
* @throws InvalidArgumentException |
|
925
|
|
|
* @return void |
|
926
|
|
|
*/ |
|
927
|
|
|
public static function nullOrNotFalse($value, $message = '') |
|
928
|
|
|
{ |
|
929
|
|
|
static::__callStatic('nullOrNotFalse', [$value, $message]); |
|
930
|
|
|
} |
|
931
|
|
|
|
|
932
|
|
|
/** |
|
933
|
|
|
* @psalm-pure |
|
934
|
|
|
* |
|
935
|
|
|
* @param mixed $value |
|
936
|
|
|
* @param string $message |
|
937
|
|
|
* |
|
938
|
|
|
* @throws InvalidArgumentException |
|
939
|
|
|
* @return void |
|
940
|
|
|
*/ |
|
941
|
|
|
public static function allNotFalse($value, $message = '') |
|
942
|
|
|
{ |
|
943
|
|
|
static::__callStatic('allNotFalse', [$value, $message]); |
|
944
|
|
|
} |
|
945
|
|
|
|
|
946
|
|
|
/** |
|
947
|
|
|
* @param mixed $value |
|
948
|
|
|
* @param string $message |
|
949
|
|
|
* |
|
950
|
|
|
* @throws InvalidArgumentException |
|
951
|
|
|
* @return void |
|
952
|
|
|
*/ |
|
953
|
|
|
public static function nullOrIp($value, $message = '') |
|
954
|
|
|
{ |
|
955
|
|
|
static::__callStatic('nullOrIp', [$value, $message]); |
|
956
|
|
|
} |
|
957
|
|
|
|
|
958
|
|
|
/** |
|
959
|
|
|
* @param mixed $value |
|
960
|
|
|
* @param string $message |
|
961
|
|
|
* |
|
962
|
|
|
* @throws InvalidArgumentException |
|
963
|
|
|
* @return void |
|
964
|
|
|
*/ |
|
965
|
|
|
public static function allIp($value, $message = '') |
|
966
|
|
|
{ |
|
967
|
|
|
static::__callStatic('allIp', [$value, $message]); |
|
968
|
|
|
} |
|
969
|
|
|
|
|
970
|
|
|
/** |
|
971
|
|
|
* @param mixed $value |
|
972
|
|
|
* @param string $message |
|
973
|
|
|
* |
|
974
|
|
|
* @throws InvalidArgumentException |
|
975
|
|
|
* @return void |
|
976
|
|
|
*/ |
|
977
|
|
|
public static function nullOrIpv4($value, $message = '') |
|
978
|
|
|
{ |
|
979
|
|
|
static::__callStatic('nullOrIpv4', [$value, $message]); |
|
980
|
|
|
} |
|
981
|
|
|
|
|
982
|
|
|
/** |
|
983
|
|
|
* @param mixed $value |
|
984
|
|
|
* @param string $message |
|
985
|
|
|
* |
|
986
|
|
|
* @throws InvalidArgumentException |
|
987
|
|
|
* @return void |
|
988
|
|
|
*/ |
|
989
|
|
|
public static function allIpv4($value, $message = '') |
|
990
|
|
|
{ |
|
991
|
|
|
static::__callStatic('allIpv4', [$value, $message]); |
|
992
|
|
|
} |
|
993
|
|
|
|
|
994
|
|
|
/** |
|
995
|
|
|
* @param mixed $value |
|
996
|
|
|
* @param string $message |
|
997
|
|
|
* |
|
998
|
|
|
* @throws InvalidArgumentException |
|
999
|
|
|
* @return void |
|
1000
|
|
|
*/ |
|
1001
|
|
|
public static function nullOrIpv6($value, $message = '') |
|
1002
|
|
|
{ |
|
1003
|
|
|
static::__callStatic('nullOrIpv6', [$value, $message]); |
|
1004
|
|
|
} |
|
1005
|
|
|
|
|
1006
|
|
|
/** |
|
1007
|
|
|
* @param mixed $value |
|
1008
|
|
|
* @param string $message |
|
1009
|
|
|
* |
|
1010
|
|
|
* @throws InvalidArgumentException |
|
1011
|
|
|
* @return void |
|
1012
|
|
|
*/ |
|
1013
|
|
|
public static function allIpv6($value, $message = '') |
|
1014
|
|
|
{ |
|
1015
|
|
|
static::__callStatic('allIpv6', [$value, $message]); |
|
1016
|
|
|
} |
|
1017
|
|
|
|
|
1018
|
|
|
/** |
|
1019
|
|
|
* @param mixed $value |
|
1020
|
|
|
* @param string $message |
|
1021
|
|
|
* |
|
1022
|
|
|
* @throws InvalidArgumentException |
|
1023
|
|
|
* @return void |
|
1024
|
|
|
*/ |
|
1025
|
|
|
public static function nullOrEmail($value, $message = '') |
|
1026
|
|
|
{ |
|
1027
|
|
|
static::__callStatic('nullOrEmail', [$value, $message]); |
|
1028
|
|
|
} |
|
1029
|
|
|
|
|
1030
|
|
|
/** |
|
1031
|
|
|
* @param mixed $value |
|
1032
|
|
|
* @param string $message |
|
1033
|
|
|
* |
|
1034
|
|
|
* @throws InvalidArgumentException |
|
1035
|
|
|
* @return void |
|
1036
|
|
|
*/ |
|
1037
|
|
|
public static function allEmail($value, $message = '') |
|
1038
|
|
|
{ |
|
1039
|
|
|
static::__callStatic('allEmail', [$value, $message]); |
|
1040
|
|
|
} |
|
1041
|
|
|
|
|
1042
|
|
|
/** |
|
1043
|
|
|
* @param array|null $values |
|
1044
|
|
|
* @param string $message |
|
1045
|
|
|
* |
|
1046
|
|
|
* @throws InvalidArgumentException |
|
1047
|
|
|
* @return void |
|
1048
|
|
|
*/ |
|
1049
|
|
|
public static function nullOrUniqueValues($values, $message = '') |
|
1050
|
|
|
{ |
|
1051
|
|
|
static::__callStatic('nullOrUniqueValues', [$values, $message]); |
|
1052
|
|
|
} |
|
1053
|
|
|
|
|
1054
|
|
|
/** |
|
1055
|
|
|
* @param iterable<array> $values |
|
|
|
|
|
|
1056
|
|
|
* @param string $message |
|
1057
|
|
|
* |
|
1058
|
|
|
* @throws InvalidArgumentException |
|
1059
|
|
|
* @return void |
|
1060
|
|
|
*/ |
|
1061
|
|
|
public static function allUniqueValues($values, $message = '') |
|
1062
|
|
|
{ |
|
1063
|
|
|
static::__callStatic('allUniqueValues', [$values, $message]); |
|
1064
|
|
|
} |
|
1065
|
|
|
|
|
1066
|
|
|
/** |
|
1067
|
|
|
* @param mixed $value |
|
1068
|
|
|
* @param mixed $expect |
|
1069
|
|
|
* @param string $message |
|
1070
|
|
|
* |
|
1071
|
|
|
* @throws InvalidArgumentException |
|
1072
|
|
|
* @return void |
|
1073
|
|
|
*/ |
|
1074
|
|
|
public static function nullOrEq($value, $expect, $message = '') |
|
1075
|
|
|
{ |
|
1076
|
|
|
static::__callStatic('nullOrEq', [$value, $expect, $message]); |
|
1077
|
|
|
} |
|
1078
|
|
|
|
|
1079
|
|
|
/** |
|
1080
|
|
|
* @param mixed $value |
|
1081
|
|
|
* @param mixed $expect |
|
1082
|
|
|
* @param string $message |
|
1083
|
|
|
* |
|
1084
|
|
|
* @throws InvalidArgumentException |
|
1085
|
|
|
* @return void |
|
1086
|
|
|
*/ |
|
1087
|
|
|
public static function allEq($value, $expect, $message = '') |
|
1088
|
|
|
{ |
|
1089
|
|
|
static::__callStatic('allEq', [$value, $expect, $message]); |
|
1090
|
|
|
} |
|
1091
|
|
|
|
|
1092
|
|
|
/** |
|
1093
|
|
|
* @param mixed $value |
|
1094
|
|
|
* @param mixed $expect |
|
1095
|
|
|
* @param string $message |
|
1096
|
|
|
* |
|
1097
|
|
|
* @throws InvalidArgumentException |
|
1098
|
|
|
* @return void |
|
1099
|
|
|
*/ |
|
1100
|
|
|
public static function nullOrNotEq($value, $expect, $message = '') |
|
1101
|
|
|
{ |
|
1102
|
|
|
static::__callStatic('nullOrNotEq', [$value, $expect, $message]); |
|
1103
|
|
|
} |
|
1104
|
|
|
|
|
1105
|
|
|
/** |
|
1106
|
|
|
* @param mixed $value |
|
1107
|
|
|
* @param mixed $expect |
|
1108
|
|
|
* @param string $message |
|
1109
|
|
|
* |
|
1110
|
|
|
* @throws InvalidArgumentException |
|
1111
|
|
|
* @return void |
|
1112
|
|
|
*/ |
|
1113
|
|
|
public static function allNotEq($value, $expect, $message = '') |
|
1114
|
|
|
{ |
|
1115
|
|
|
static::__callStatic('allNotEq', [$value, $expect, $message]); |
|
1116
|
|
|
} |
|
1117
|
|
|
|
|
1118
|
|
|
/** |
|
1119
|
|
|
* @psalm-pure |
|
1120
|
|
|
* |
|
1121
|
|
|
* @param mixed $value |
|
1122
|
|
|
* @param mixed $expect |
|
1123
|
|
|
* @param string $message |
|
1124
|
|
|
* |
|
1125
|
|
|
* @throws InvalidArgumentException |
|
1126
|
|
|
* @return void |
|
1127
|
|
|
*/ |
|
1128
|
|
|
public static function nullOrSame($value, $expect, $message = '') |
|
1129
|
|
|
{ |
|
1130
|
|
|
static::__callStatic('nullOrSame', [$value, $expect, $message]); |
|
1131
|
|
|
} |
|
1132
|
|
|
|
|
1133
|
|
|
/** |
|
1134
|
|
|
* @psalm-pure |
|
1135
|
|
|
* |
|
1136
|
|
|
* @param mixed $value |
|
1137
|
|
|
* @param mixed $expect |
|
1138
|
|
|
* @param string $message |
|
1139
|
|
|
* |
|
1140
|
|
|
* @throws InvalidArgumentException |
|
1141
|
|
|
* @return void |
|
1142
|
|
|
*/ |
|
1143
|
|
|
public static function allSame($value, $expect, $message = '') |
|
1144
|
|
|
{ |
|
1145
|
|
|
static::__callStatic('allSame', [$value, $expect, $message]); |
|
1146
|
|
|
} |
|
1147
|
|
|
|
|
1148
|
|
|
/** |
|
1149
|
|
|
* @psalm-pure |
|
1150
|
|
|
* |
|
1151
|
|
|
* @param mixed $value |
|
1152
|
|
|
* @param mixed $expect |
|
1153
|
|
|
* @param string $message |
|
1154
|
|
|
* |
|
1155
|
|
|
* @throws InvalidArgumentException |
|
1156
|
|
|
* @return void |
|
1157
|
|
|
*/ |
|
1158
|
|
|
public static function nullOrNotSame($value, $expect, $message = '') |
|
1159
|
|
|
{ |
|
1160
|
|
|
static::__callStatic('nullOrNotSame', [$value, $expect, $message]); |
|
1161
|
|
|
} |
|
1162
|
|
|
|
|
1163
|
|
|
/** |
|
1164
|
|
|
* @psalm-pure |
|
1165
|
|
|
* |
|
1166
|
|
|
* @param mixed $value |
|
1167
|
|
|
* @param mixed $expect |
|
1168
|
|
|
* @param string $message |
|
1169
|
|
|
* |
|
1170
|
|
|
* @throws InvalidArgumentException |
|
1171
|
|
|
* @return void |
|
1172
|
|
|
*/ |
|
1173
|
|
|
public static function allNotSame($value, $expect, $message = '') |
|
1174
|
|
|
{ |
|
1175
|
|
|
static::__callStatic('allNotSame', [$value, $expect, $message]); |
|
1176
|
|
|
} |
|
1177
|
|
|
|
|
1178
|
|
|
/** |
|
1179
|
|
|
* @psalm-pure |
|
1180
|
|
|
* |
|
1181
|
|
|
* @param mixed $value |
|
1182
|
|
|
* @param mixed $limit |
|
1183
|
|
|
* @param string $message |
|
1184
|
|
|
* |
|
1185
|
|
|
* @throws InvalidArgumentException |
|
1186
|
|
|
* @return void |
|
1187
|
|
|
*/ |
|
1188
|
|
|
public static function nullOrGreaterThan($value, $limit, $message = '') |
|
1189
|
|
|
{ |
|
1190
|
|
|
static::__callStatic('nullOrGreaterThan', [$value, $limit, $message]); |
|
1191
|
|
|
} |
|
1192
|
|
|
|
|
1193
|
|
|
/** |
|
1194
|
|
|
* @psalm-pure |
|
1195
|
|
|
* |
|
1196
|
|
|
* @param mixed $value |
|
1197
|
|
|
* @param mixed $limit |
|
1198
|
|
|
* @param string $message |
|
1199
|
|
|
* |
|
1200
|
|
|
* @throws InvalidArgumentException |
|
1201
|
|
|
* @return void |
|
1202
|
|
|
*/ |
|
1203
|
|
|
public static function allGreaterThan($value, $limit, $message = '') |
|
1204
|
|
|
{ |
|
1205
|
|
|
static::__callStatic('allGreaterThan', [$value, $limit, $message]); |
|
1206
|
|
|
} |
|
1207
|
|
|
|
|
1208
|
|
|
/** |
|
1209
|
|
|
* @psalm-pure |
|
1210
|
|
|
* |
|
1211
|
|
|
* @param mixed $value |
|
1212
|
|
|
* @param mixed $limit |
|
1213
|
|
|
* @param string $message |
|
1214
|
|
|
* |
|
1215
|
|
|
* @throws InvalidArgumentException |
|
1216
|
|
|
* @return void |
|
1217
|
|
|
*/ |
|
1218
|
|
|
public static function nullOrGreaterThanEq($value, $limit, $message = '') |
|
1219
|
|
|
{ |
|
1220
|
|
|
static::__callStatic('nullOrGreaterThanEq', [$value, $limit, $message]); |
|
1221
|
|
|
} |
|
1222
|
|
|
|
|
1223
|
|
|
/** |
|
1224
|
|
|
* @psalm-pure |
|
1225
|
|
|
* |
|
1226
|
|
|
* @param mixed $value |
|
1227
|
|
|
* @param mixed $limit |
|
1228
|
|
|
* @param string $message |
|
1229
|
|
|
* |
|
1230
|
|
|
* @throws InvalidArgumentException |
|
1231
|
|
|
* @return void |
|
1232
|
|
|
*/ |
|
1233
|
|
|
public static function allGreaterThanEq($value, $limit, $message = '') |
|
1234
|
|
|
{ |
|
1235
|
|
|
static::__callStatic('allGreaterThanEq', [$value, $limit, $message]); |
|
1236
|
|
|
} |
|
1237
|
|
|
|
|
1238
|
|
|
/** |
|
1239
|
|
|
* @psalm-pure |
|
1240
|
|
|
* |
|
1241
|
|
|
* @param mixed $value |
|
1242
|
|
|
* @param mixed $limit |
|
1243
|
|
|
* @param string $message |
|
1244
|
|
|
* |
|
1245
|
|
|
* @throws InvalidArgumentException |
|
1246
|
|
|
* @return void |
|
1247
|
|
|
*/ |
|
1248
|
|
|
public static function nullOrLessThan($value, $limit, $message = '') |
|
1249
|
|
|
{ |
|
1250
|
|
|
static::__callStatic('nullOrLessThan', [$value, $limit, $message]); |
|
1251
|
|
|
} |
|
1252
|
|
|
|
|
1253
|
|
|
/** |
|
1254
|
|
|
* @psalm-pure |
|
1255
|
|
|
* |
|
1256
|
|
|
* @param mixed $value |
|
1257
|
|
|
* @param mixed $limit |
|
1258
|
|
|
* @param string $message |
|
1259
|
|
|
* |
|
1260
|
|
|
* @throws InvalidArgumentException |
|
1261
|
|
|
* @return void |
|
1262
|
|
|
*/ |
|
1263
|
|
|
public static function allLessThan($value, $limit, $message = '') |
|
1264
|
|
|
{ |
|
1265
|
|
|
static::__callStatic('allLessThan', [$value, $limit, $message]); |
|
1266
|
|
|
} |
|
1267
|
|
|
|
|
1268
|
|
|
/** |
|
1269
|
|
|
* @psalm-pure |
|
1270
|
|
|
* |
|
1271
|
|
|
* @param mixed $value |
|
1272
|
|
|
* @param mixed $limit |
|
1273
|
|
|
* @param string $message |
|
1274
|
|
|
* |
|
1275
|
|
|
* @throws InvalidArgumentException |
|
1276
|
|
|
* @return void |
|
1277
|
|
|
*/ |
|
1278
|
|
|
public static function nullOrLessThanEq($value, $limit, $message = '') |
|
1279
|
|
|
{ |
|
1280
|
|
|
static::__callStatic('nullOrLessThanEq', [$value, $limit, $message]); |
|
1281
|
|
|
} |
|
1282
|
|
|
|
|
1283
|
|
|
/** |
|
1284
|
|
|
* @psalm-pure |
|
1285
|
|
|
* |
|
1286
|
|
|
* @param mixed $value |
|
1287
|
|
|
* @param mixed $limit |
|
1288
|
|
|
* @param string $message |
|
1289
|
|
|
* |
|
1290
|
|
|
* @throws InvalidArgumentException |
|
1291
|
|
|
* @return void |
|
1292
|
|
|
*/ |
|
1293
|
|
|
public static function allLessThanEq($value, $limit, $message = '') |
|
1294
|
|
|
{ |
|
1295
|
|
|
static::__callStatic('allLessThanEq', [$value, $limit, $message]); |
|
1296
|
|
|
} |
|
1297
|
|
|
|
|
1298
|
|
|
/** |
|
1299
|
|
|
* @psalm-pure |
|
1300
|
|
|
* |
|
1301
|
|
|
* @param mixed $value |
|
1302
|
|
|
* @param mixed $min |
|
1303
|
|
|
* @param mixed $max |
|
1304
|
|
|
* @param string $message |
|
1305
|
|
|
* |
|
1306
|
|
|
* @throws InvalidArgumentException |
|
1307
|
|
|
* @return void |
|
1308
|
|
|
*/ |
|
1309
|
|
|
public static function nullOrRange($value, $min, $max, $message = '') |
|
1310
|
|
|
{ |
|
1311
|
|
|
static::__callStatic('nullOrRange', [$value, $min, $max, $message]); |
|
1312
|
|
|
} |
|
1313
|
|
|
|
|
1314
|
|
|
/** |
|
1315
|
|
|
* @psalm-pure |
|
1316
|
|
|
* |
|
1317
|
|
|
* @param mixed $value |
|
1318
|
|
|
* @param mixed $min |
|
1319
|
|
|
* @param mixed $max |
|
1320
|
|
|
* @param string $message |
|
1321
|
|
|
* |
|
1322
|
|
|
* @throws InvalidArgumentException |
|
1323
|
|
|
* @return void |
|
1324
|
|
|
*/ |
|
1325
|
|
|
public static function allRange($value, $min, $max, $message = '') |
|
1326
|
|
|
{ |
|
1327
|
|
|
static::__callStatic('allRange', [$value, $min, $max, $message]); |
|
1328
|
|
|
} |
|
1329
|
|
|
|
|
1330
|
|
|
/** |
|
1331
|
|
|
* @psalm-pure |
|
1332
|
|
|
* |
|
1333
|
|
|
* @param mixed $value |
|
1334
|
|
|
* @param array $values |
|
1335
|
|
|
* @param string $message |
|
1336
|
|
|
* |
|
1337
|
|
|
* @throws InvalidArgumentException |
|
1338
|
|
|
* @return void |
|
1339
|
|
|
*/ |
|
1340
|
|
|
public static function nullOrOneOf($value, $values, $message = '') |
|
1341
|
|
|
{ |
|
1342
|
|
|
static::__callStatic('nullOrOneOf', [$value, $values, $message]); |
|
1343
|
|
|
} |
|
1344
|
|
|
|
|
1345
|
|
|
/** |
|
1346
|
|
|
* @psalm-pure |
|
1347
|
|
|
* |
|
1348
|
|
|
* @param mixed $value |
|
1349
|
|
|
* @param array $values |
|
1350
|
|
|
* @param string $message |
|
1351
|
|
|
* |
|
1352
|
|
|
* @throws InvalidArgumentException |
|
1353
|
|
|
* @return void |
|
1354
|
|
|
*/ |
|
1355
|
|
|
public static function allOneOf($value, $values, $message = '') |
|
1356
|
|
|
{ |
|
1357
|
|
|
static::__callStatic('allOneOf', [$value, $values, $message]); |
|
1358
|
|
|
} |
|
1359
|
|
|
|
|
1360
|
|
|
/** |
|
1361
|
|
|
* @psalm-pure |
|
1362
|
|
|
* |
|
1363
|
|
|
* @param mixed $value |
|
1364
|
|
|
* @param array $values |
|
1365
|
|
|
* @param string $message |
|
1366
|
|
|
* |
|
1367
|
|
|
* @throws InvalidArgumentException |
|
1368
|
|
|
* @return void |
|
1369
|
|
|
*/ |
|
1370
|
|
|
public static function nullOrInArray($value, $values, $message = '') |
|
1371
|
|
|
{ |
|
1372
|
|
|
static::__callStatic('nullOrInArray', [$value, $values, $message]); |
|
1373
|
|
|
} |
|
1374
|
|
|
|
|
1375
|
|
|
/** |
|
1376
|
|
|
* @psalm-pure |
|
1377
|
|
|
* |
|
1378
|
|
|
* @param mixed $value |
|
1379
|
|
|
* @param array $values |
|
1380
|
|
|
* @param string $message |
|
1381
|
|
|
* |
|
1382
|
|
|
* @throws InvalidArgumentException |
|
1383
|
|
|
* @return void |
|
1384
|
|
|
*/ |
|
1385
|
|
|
public static function allInArray($value, $values, $message = '') |
|
1386
|
|
|
{ |
|
1387
|
|
|
static::__callStatic('allInArray', [$value, $values, $message]); |
|
1388
|
|
|
} |
|
1389
|
|
|
|
|
1390
|
|
|
/** |
|
1391
|
|
|
* @psalm-pure |
|
1392
|
|
|
* |
|
1393
|
|
|
* @param string|null $value |
|
1394
|
|
|
* @param string $subString |
|
1395
|
|
|
* @param string $message |
|
1396
|
|
|
* |
|
1397
|
|
|
* @throws InvalidArgumentException |
|
1398
|
|
|
* @return void |
|
1399
|
|
|
*/ |
|
1400
|
|
|
public static function nullOrContains($value, $subString, $message = '') |
|
1401
|
|
|
{ |
|
1402
|
|
|
static::__callStatic('nullOrContains', [$value, $subString, $message]); |
|
1403
|
|
|
} |
|
1404
|
|
|
|
|
1405
|
|
|
/** |
|
1406
|
|
|
* @psalm-pure |
|
1407
|
|
|
* |
|
1408
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1409
|
|
|
* @param string $subString |
|
1410
|
|
|
* @param string $message |
|
1411
|
|
|
* |
|
1412
|
|
|
* @throws InvalidArgumentException |
|
1413
|
|
|
* @return void |
|
1414
|
|
|
*/ |
|
1415
|
|
|
public static function allContains($value, $subString, $message = '') |
|
1416
|
|
|
{ |
|
1417
|
|
|
static::__callStatic('allContains', [$value, $subString, $message]); |
|
1418
|
|
|
} |
|
1419
|
|
|
|
|
1420
|
|
|
/** |
|
1421
|
|
|
* @psalm-pure |
|
1422
|
|
|
* |
|
1423
|
|
|
* @param string|null $value |
|
1424
|
|
|
* @param string $subString |
|
1425
|
|
|
* @param string $message |
|
1426
|
|
|
* |
|
1427
|
|
|
* @throws InvalidArgumentException |
|
1428
|
|
|
* @return void |
|
1429
|
|
|
*/ |
|
1430
|
|
|
public static function nullOrNotContains($value, $subString, $message = '') |
|
1431
|
|
|
{ |
|
1432
|
|
|
static::__callStatic('nullOrNotContains', [$value, $subString, $message]); |
|
1433
|
|
|
} |
|
1434
|
|
|
|
|
1435
|
|
|
/** |
|
1436
|
|
|
* @psalm-pure |
|
1437
|
|
|
* |
|
1438
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1439
|
|
|
* @param string $subString |
|
1440
|
|
|
* @param string $message |
|
1441
|
|
|
* |
|
1442
|
|
|
* @throws InvalidArgumentException |
|
1443
|
|
|
* @return void |
|
1444
|
|
|
*/ |
|
1445
|
|
|
public static function allNotContains($value, $subString, $message = '') |
|
1446
|
|
|
{ |
|
1447
|
|
|
static::__callStatic('allNotContains', [$value, $subString, $message]); |
|
1448
|
|
|
} |
|
1449
|
|
|
|
|
1450
|
|
|
/** |
|
1451
|
|
|
* @psalm-pure |
|
1452
|
|
|
* |
|
1453
|
|
|
* @param string|null $value |
|
1454
|
|
|
* @param string $message |
|
1455
|
|
|
* |
|
1456
|
|
|
* @throws InvalidArgumentException |
|
1457
|
|
|
* @return void |
|
1458
|
|
|
*/ |
|
1459
|
|
|
public static function nullOrNotWhitespaceOnly($value, $message = '') |
|
1460
|
|
|
{ |
|
1461
|
|
|
static::__callStatic('nullOrNotWhitespaceOnly', [$value, $message]); |
|
1462
|
|
|
} |
|
1463
|
|
|
|
|
1464
|
|
|
/** |
|
1465
|
|
|
* @psalm-pure |
|
1466
|
|
|
* |
|
1467
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1468
|
|
|
* @param string $message |
|
1469
|
|
|
* |
|
1470
|
|
|
* @throws InvalidArgumentException |
|
1471
|
|
|
* @return void |
|
1472
|
|
|
*/ |
|
1473
|
|
|
public static function allNotWhitespaceOnly($value, $message = '') |
|
1474
|
|
|
{ |
|
1475
|
|
|
static::__callStatic('allNotWhitespaceOnly', [$value, $message]); |
|
1476
|
|
|
} |
|
1477
|
|
|
|
|
1478
|
|
|
/** |
|
1479
|
|
|
* @psalm-pure |
|
1480
|
|
|
* |
|
1481
|
|
|
* @param string|null $value |
|
1482
|
|
|
* @param string $prefix |
|
1483
|
|
|
* @param string $message |
|
1484
|
|
|
* |
|
1485
|
|
|
* @throws InvalidArgumentException |
|
1486
|
|
|
* @return void |
|
1487
|
|
|
*/ |
|
1488
|
|
|
public static function nullOrStartsWith($value, $prefix, $message = '') |
|
1489
|
|
|
{ |
|
1490
|
|
|
static::__callStatic('nullOrStartsWith', [$value, $prefix, $message]); |
|
1491
|
|
|
} |
|
1492
|
|
|
|
|
1493
|
|
|
/** |
|
1494
|
|
|
* @psalm-pure |
|
1495
|
|
|
* |
|
1496
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1497
|
|
|
* @param string $prefix |
|
1498
|
|
|
* @param string $message |
|
1499
|
|
|
* |
|
1500
|
|
|
* @throws InvalidArgumentException |
|
1501
|
|
|
* @return void |
|
1502
|
|
|
*/ |
|
1503
|
|
|
public static function allStartsWith($value, $prefix, $message = '') |
|
1504
|
|
|
{ |
|
1505
|
|
|
static::__callStatic('allStartsWith', [$value, $prefix, $message]); |
|
1506
|
|
|
} |
|
1507
|
|
|
|
|
1508
|
|
|
/** |
|
1509
|
|
|
* @psalm-pure |
|
1510
|
|
|
* |
|
1511
|
|
|
* @param string|null $value |
|
1512
|
|
|
* @param string $prefix |
|
1513
|
|
|
* @param string $message |
|
1514
|
|
|
* |
|
1515
|
|
|
* @throws InvalidArgumentException |
|
1516
|
|
|
* @return void |
|
1517
|
|
|
*/ |
|
1518
|
|
|
public static function nullOrNotStartsWith($value, $prefix, $message = '') |
|
1519
|
|
|
{ |
|
1520
|
|
|
static::__callStatic('nullOrNotStartsWith', [$value, $prefix, $message]); |
|
1521
|
|
|
} |
|
1522
|
|
|
|
|
1523
|
|
|
/** |
|
1524
|
|
|
* @psalm-pure |
|
1525
|
|
|
* |
|
1526
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1527
|
|
|
* @param string $prefix |
|
1528
|
|
|
* @param string $message |
|
1529
|
|
|
* |
|
1530
|
|
|
* @throws InvalidArgumentException |
|
1531
|
|
|
* @return void |
|
1532
|
|
|
*/ |
|
1533
|
|
|
public static function allNotStartsWith($value, $prefix, $message = '') |
|
1534
|
|
|
{ |
|
1535
|
|
|
static::__callStatic('allNotStartsWith', [$value, $prefix, $message]); |
|
1536
|
|
|
} |
|
1537
|
|
|
|
|
1538
|
|
|
/** |
|
1539
|
|
|
* @psalm-pure |
|
1540
|
|
|
* |
|
1541
|
|
|
* @param mixed $value |
|
1542
|
|
|
* @param string $message |
|
1543
|
|
|
* |
|
1544
|
|
|
* @throws InvalidArgumentException |
|
1545
|
|
|
* @return void |
|
1546
|
|
|
*/ |
|
1547
|
|
|
public static function nullOrStartsWithLetter($value, $message = '') |
|
1548
|
|
|
{ |
|
1549
|
|
|
static::__callStatic('nullOrStartsWithLetter', [$value, $message]); |
|
1550
|
|
|
} |
|
1551
|
|
|
|
|
1552
|
|
|
/** |
|
1553
|
|
|
* @psalm-pure |
|
1554
|
|
|
* |
|
1555
|
|
|
* @param mixed $value |
|
1556
|
|
|
* @param string $message |
|
1557
|
|
|
* |
|
1558
|
|
|
* @throws InvalidArgumentException |
|
1559
|
|
|
* @return void |
|
1560
|
|
|
*/ |
|
1561
|
|
|
public static function allStartsWithLetter($value, $message = '') |
|
1562
|
|
|
{ |
|
1563
|
|
|
static::__callStatic('allStartsWithLetter', [$value, $message]); |
|
1564
|
|
|
} |
|
1565
|
|
|
|
|
1566
|
|
|
/** |
|
1567
|
|
|
* @psalm-pure |
|
1568
|
|
|
* |
|
1569
|
|
|
* @param string|null $value |
|
1570
|
|
|
* @param string $suffix |
|
1571
|
|
|
* @param string $message |
|
1572
|
|
|
* |
|
1573
|
|
|
* @throws InvalidArgumentException |
|
1574
|
|
|
* @return void |
|
1575
|
|
|
*/ |
|
1576
|
|
|
public static function nullOrEndsWith($value, $suffix, $message = '') |
|
1577
|
|
|
{ |
|
1578
|
|
|
static::__callStatic('nullOrEndsWith', [$value, $suffix, $message]); |
|
1579
|
|
|
} |
|
1580
|
|
|
|
|
1581
|
|
|
/** |
|
1582
|
|
|
* @psalm-pure |
|
1583
|
|
|
* |
|
1584
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1585
|
|
|
* @param string $suffix |
|
1586
|
|
|
* @param string $message |
|
1587
|
|
|
* |
|
1588
|
|
|
* @throws InvalidArgumentException |
|
1589
|
|
|
* @return void |
|
1590
|
|
|
*/ |
|
1591
|
|
|
public static function allEndsWith($value, $suffix, $message = '') |
|
1592
|
|
|
{ |
|
1593
|
|
|
static::__callStatic('allEndsWith', [$value, $suffix, $message]); |
|
1594
|
|
|
} |
|
1595
|
|
|
|
|
1596
|
|
|
/** |
|
1597
|
|
|
* @psalm-pure |
|
1598
|
|
|
* |
|
1599
|
|
|
* @param string|null $value |
|
1600
|
|
|
* @param string $suffix |
|
1601
|
|
|
* @param string $message |
|
1602
|
|
|
* |
|
1603
|
|
|
* @throws InvalidArgumentException |
|
1604
|
|
|
* @return void |
|
1605
|
|
|
*/ |
|
1606
|
|
|
public static function nullOrNotEndsWith($value, $suffix, $message = '') |
|
1607
|
|
|
{ |
|
1608
|
|
|
static::__callStatic('nullOrNotEndsWith', [$value, $suffix, $message]); |
|
1609
|
|
|
} |
|
1610
|
|
|
|
|
1611
|
|
|
/** |
|
1612
|
|
|
* @psalm-pure |
|
1613
|
|
|
* |
|
1614
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1615
|
|
|
* @param string $suffix |
|
1616
|
|
|
* @param string $message |
|
1617
|
|
|
* |
|
1618
|
|
|
* @throws InvalidArgumentException |
|
1619
|
|
|
* @return void |
|
1620
|
|
|
*/ |
|
1621
|
|
|
public static function allNotEndsWith($value, $suffix, $message = '') |
|
1622
|
|
|
{ |
|
1623
|
|
|
static::__callStatic('allNotEndsWith', [$value, $suffix, $message]); |
|
1624
|
|
|
} |
|
1625
|
|
|
|
|
1626
|
|
|
/** |
|
1627
|
|
|
* @psalm-pure |
|
1628
|
|
|
* |
|
1629
|
|
|
* @param string|null $value |
|
1630
|
|
|
* @param string $pattern |
|
1631
|
|
|
* @param string $message |
|
1632
|
|
|
* |
|
1633
|
|
|
* @throws InvalidArgumentException |
|
1634
|
|
|
* @return void |
|
1635
|
|
|
*/ |
|
1636
|
|
|
public static function nullOrRegex($value, $pattern, $message = '') |
|
1637
|
|
|
{ |
|
1638
|
|
|
static::__callStatic('nullOrRegex', [$value, $pattern, $message]); |
|
1639
|
|
|
} |
|
1640
|
|
|
|
|
1641
|
|
|
/** |
|
1642
|
|
|
* @psalm-pure |
|
1643
|
|
|
* |
|
1644
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1645
|
|
|
* @param string $pattern |
|
1646
|
|
|
* @param string $message |
|
1647
|
|
|
* |
|
1648
|
|
|
* @throws InvalidArgumentException |
|
1649
|
|
|
* @return void |
|
1650
|
|
|
*/ |
|
1651
|
|
|
public static function allRegex($value, $pattern, $message = '') |
|
1652
|
|
|
{ |
|
1653
|
|
|
static::__callStatic('allRegex', [$value, $pattern, $message]); |
|
1654
|
|
|
} |
|
1655
|
|
|
|
|
1656
|
|
|
/** |
|
1657
|
|
|
* @psalm-pure |
|
1658
|
|
|
* |
|
1659
|
|
|
* @param string|null $value |
|
1660
|
|
|
* @param string $pattern |
|
1661
|
|
|
* @param string $message |
|
1662
|
|
|
* |
|
1663
|
|
|
* @throws InvalidArgumentException |
|
1664
|
|
|
* @return void |
|
1665
|
|
|
*/ |
|
1666
|
|
|
public static function nullOrNotRegex($value, $pattern, $message = '') |
|
1667
|
|
|
{ |
|
1668
|
|
|
static::__callStatic('nullOrNotRegex', [$value, $pattern, $message]); |
|
1669
|
|
|
} |
|
1670
|
|
|
|
|
1671
|
|
|
/** |
|
1672
|
|
|
* @psalm-pure |
|
1673
|
|
|
* |
|
1674
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1675
|
|
|
* @param string $pattern |
|
1676
|
|
|
* @param string $message |
|
1677
|
|
|
* |
|
1678
|
|
|
* @throws InvalidArgumentException |
|
1679
|
|
|
* @return void |
|
1680
|
|
|
*/ |
|
1681
|
|
|
public static function allNotRegex($value, $pattern, $message = '') |
|
1682
|
|
|
{ |
|
1683
|
|
|
static::__callStatic('allNotRegex', [$value, $pattern, $message]); |
|
1684
|
|
|
} |
|
1685
|
|
|
|
|
1686
|
|
|
/** |
|
1687
|
|
|
* @psalm-pure |
|
1688
|
|
|
* |
|
1689
|
|
|
* @param mixed $value |
|
1690
|
|
|
* @param string $message |
|
1691
|
|
|
* |
|
1692
|
|
|
* @throws InvalidArgumentException |
|
1693
|
|
|
* @return void |
|
1694
|
|
|
*/ |
|
1695
|
|
|
public static function nullOrUnicodeLetters($value, $message = '') |
|
1696
|
|
|
{ |
|
1697
|
|
|
static::__callStatic('nullOrUnicodeLetters', [$value, $message]); |
|
1698
|
|
|
} |
|
1699
|
|
|
|
|
1700
|
|
|
/** |
|
1701
|
|
|
* @psalm-pure |
|
1702
|
|
|
* |
|
1703
|
|
|
* @param mixed $value |
|
1704
|
|
|
* @param string $message |
|
1705
|
|
|
* |
|
1706
|
|
|
* @throws InvalidArgumentException |
|
1707
|
|
|
* @return void |
|
1708
|
|
|
*/ |
|
1709
|
|
|
public static function allUnicodeLetters($value, $message = '') |
|
1710
|
|
|
{ |
|
1711
|
|
|
static::__callStatic('allUnicodeLetters', [$value, $message]); |
|
1712
|
|
|
} |
|
1713
|
|
|
|
|
1714
|
|
|
/** |
|
1715
|
|
|
* @psalm-pure |
|
1716
|
|
|
* |
|
1717
|
|
|
* @param mixed $value |
|
1718
|
|
|
* @param string $message |
|
1719
|
|
|
* |
|
1720
|
|
|
* @throws InvalidArgumentException |
|
1721
|
|
|
* @return void |
|
1722
|
|
|
*/ |
|
1723
|
|
|
public static function nullOrAlpha($value, $message = '') |
|
1724
|
|
|
{ |
|
1725
|
|
|
static::__callStatic('nullOrAlpha', [$value, $message]); |
|
1726
|
|
|
} |
|
1727
|
|
|
|
|
1728
|
|
|
/** |
|
1729
|
|
|
* @psalm-pure |
|
1730
|
|
|
* |
|
1731
|
|
|
* @param mixed $value |
|
1732
|
|
|
* @param string $message |
|
1733
|
|
|
* |
|
1734
|
|
|
* @throws InvalidArgumentException |
|
1735
|
|
|
* @return void |
|
1736
|
|
|
*/ |
|
1737
|
|
|
public static function allAlpha($value, $message = '') |
|
1738
|
|
|
{ |
|
1739
|
|
|
static::__callStatic('allAlpha', [$value, $message]); |
|
1740
|
|
|
} |
|
1741
|
|
|
|
|
1742
|
|
|
/** |
|
1743
|
|
|
* @psalm-pure |
|
1744
|
|
|
* |
|
1745
|
|
|
* @param string|null $value |
|
1746
|
|
|
* @param string $message |
|
1747
|
|
|
* |
|
1748
|
|
|
* @throws InvalidArgumentException |
|
1749
|
|
|
* @return void |
|
1750
|
|
|
*/ |
|
1751
|
|
|
public static function nullOrDigits($value, $message = '') |
|
1752
|
|
|
{ |
|
1753
|
|
|
static::__callStatic('nullOrDigits', [$value, $message]); |
|
1754
|
|
|
} |
|
1755
|
|
|
|
|
1756
|
|
|
/** |
|
1757
|
|
|
* @psalm-pure |
|
1758
|
|
|
* |
|
1759
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1760
|
|
|
* @param string $message |
|
1761
|
|
|
* |
|
1762
|
|
|
* @throws InvalidArgumentException |
|
1763
|
|
|
* @return void |
|
1764
|
|
|
*/ |
|
1765
|
|
|
public static function allDigits($value, $message = '') |
|
1766
|
|
|
{ |
|
1767
|
|
|
static::__callStatic('allDigits', [$value, $message]); |
|
1768
|
|
|
} |
|
1769
|
|
|
|
|
1770
|
|
|
/** |
|
1771
|
|
|
* @psalm-pure |
|
1772
|
|
|
* |
|
1773
|
|
|
* @param string|null $value |
|
1774
|
|
|
* @param string $message |
|
1775
|
|
|
* |
|
1776
|
|
|
* @throws InvalidArgumentException |
|
1777
|
|
|
* @return void |
|
1778
|
|
|
*/ |
|
1779
|
|
|
public static function nullOrAlnum($value, $message = '') |
|
1780
|
|
|
{ |
|
1781
|
|
|
static::__callStatic('nullOrAlnum', [$value, $message]); |
|
1782
|
|
|
} |
|
1783
|
|
|
|
|
1784
|
|
|
/** |
|
1785
|
|
|
* @psalm-pure |
|
1786
|
|
|
* |
|
1787
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1788
|
|
|
* @param string $message |
|
1789
|
|
|
* |
|
1790
|
|
|
* @throws InvalidArgumentException |
|
1791
|
|
|
* @return void |
|
1792
|
|
|
*/ |
|
1793
|
|
|
public static function allAlnum($value, $message = '') |
|
1794
|
|
|
{ |
|
1795
|
|
|
static::__callStatic('allAlnum', [$value, $message]); |
|
1796
|
|
|
} |
|
1797
|
|
|
|
|
1798
|
|
|
/** |
|
1799
|
|
|
* @psalm-pure |
|
1800
|
|
|
* @psalm-assert lowercase-string|null $value |
|
1801
|
|
|
* |
|
1802
|
|
|
* @param string|null $value |
|
1803
|
|
|
* @param string $message |
|
1804
|
|
|
* |
|
1805
|
|
|
* @throws InvalidArgumentException |
|
1806
|
|
|
* @return void |
|
1807
|
|
|
*/ |
|
1808
|
|
|
public static function nullOrLower($value, $message = '') |
|
1809
|
|
|
{ |
|
1810
|
|
|
static::__callStatic('nullOrLower', [$value, $message]); |
|
1811
|
|
|
} |
|
1812
|
|
|
|
|
1813
|
|
|
/** |
|
1814
|
|
|
* @psalm-pure |
|
1815
|
|
|
* @psalm-assert iterable<lowercase-string> $value |
|
1816
|
|
|
* |
|
1817
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1818
|
|
|
* @param string $message |
|
1819
|
|
|
* |
|
1820
|
|
|
* @throws InvalidArgumentException |
|
1821
|
|
|
* @return void |
|
1822
|
|
|
*/ |
|
1823
|
|
|
public static function allLower($value, $message = '') |
|
1824
|
|
|
{ |
|
1825
|
|
|
static::__callStatic('allLower', [$value, $message]); |
|
1826
|
|
|
} |
|
1827
|
|
|
|
|
1828
|
|
|
/** |
|
1829
|
|
|
* @psalm-pure |
|
1830
|
|
|
* |
|
1831
|
|
|
* @param string|null $value |
|
1832
|
|
|
* @param string $message |
|
1833
|
|
|
* |
|
1834
|
|
|
* @throws InvalidArgumentException |
|
1835
|
|
|
* @return void |
|
1836
|
|
|
*/ |
|
1837
|
|
|
public static function nullOrUpper($value, $message = '') |
|
1838
|
|
|
{ |
|
1839
|
|
|
static::__callStatic('nullOrUpper', [$value, $message]); |
|
1840
|
|
|
} |
|
1841
|
|
|
|
|
1842
|
|
|
/** |
|
1843
|
|
|
* @psalm-pure |
|
1844
|
|
|
* |
|
1845
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1846
|
|
|
* @param string $message |
|
1847
|
|
|
* |
|
1848
|
|
|
* @throws InvalidArgumentException |
|
1849
|
|
|
* @return void |
|
1850
|
|
|
*/ |
|
1851
|
|
|
public static function allUpper($value, $message = '') |
|
1852
|
|
|
{ |
|
1853
|
|
|
static::__callStatic('allUpper', [$value, $message]); |
|
1854
|
|
|
} |
|
1855
|
|
|
|
|
1856
|
|
|
/** |
|
1857
|
|
|
* @psalm-pure |
|
1858
|
|
|
* |
|
1859
|
|
|
* @param string|null $value |
|
1860
|
|
|
* @param int $length |
|
1861
|
|
|
* @param string $message |
|
1862
|
|
|
* |
|
1863
|
|
|
* @throws InvalidArgumentException |
|
1864
|
|
|
* @return void |
|
1865
|
|
|
*/ |
|
1866
|
|
|
public static function nullOrLength($value, $length, $message = '') |
|
1867
|
|
|
{ |
|
1868
|
|
|
static::__callStatic('nullOrLength', [$value, $length, $message]); |
|
1869
|
|
|
} |
|
1870
|
|
|
|
|
1871
|
|
|
/** |
|
1872
|
|
|
* @psalm-pure |
|
1873
|
|
|
* |
|
1874
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1875
|
|
|
* @param int $length |
|
1876
|
|
|
* @param string $message |
|
1877
|
|
|
* |
|
1878
|
|
|
* @throws InvalidArgumentException |
|
1879
|
|
|
* @return void |
|
1880
|
|
|
*/ |
|
1881
|
|
|
public static function allLength($value, $length, $message = '') |
|
1882
|
|
|
{ |
|
1883
|
|
|
static::__callStatic('allLength', [$value, $length, $message]); |
|
1884
|
|
|
} |
|
1885
|
|
|
|
|
1886
|
|
|
/** |
|
1887
|
|
|
* @psalm-pure |
|
1888
|
|
|
* |
|
1889
|
|
|
* @param string|null $value |
|
1890
|
|
|
* @param int|float $min |
|
1891
|
|
|
* @param string $message |
|
1892
|
|
|
* |
|
1893
|
|
|
* @throws InvalidArgumentException |
|
1894
|
|
|
* @return void |
|
1895
|
|
|
*/ |
|
1896
|
|
|
public static function nullOrMinLength($value, $min, $message = '') |
|
1897
|
|
|
{ |
|
1898
|
|
|
static::__callStatic('nullOrMinLength', [$value, $min, $message]); |
|
1899
|
|
|
} |
|
1900
|
|
|
|
|
1901
|
|
|
/** |
|
1902
|
|
|
* @psalm-pure |
|
1903
|
|
|
* |
|
1904
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1905
|
|
|
* @param int|float $min |
|
1906
|
|
|
* @param string $message |
|
1907
|
|
|
* |
|
1908
|
|
|
* @throws InvalidArgumentException |
|
1909
|
|
|
* @return void |
|
1910
|
|
|
*/ |
|
1911
|
|
|
public static function allMinLength($value, $min, $message = '') |
|
1912
|
|
|
{ |
|
1913
|
|
|
static::__callStatic('allMinLength', [$value, $min, $message]); |
|
1914
|
|
|
} |
|
1915
|
|
|
|
|
1916
|
|
|
/** |
|
1917
|
|
|
* @psalm-pure |
|
1918
|
|
|
* |
|
1919
|
|
|
* @param string|null $value |
|
1920
|
|
|
* @param int|float $max |
|
1921
|
|
|
* @param string $message |
|
1922
|
|
|
* |
|
1923
|
|
|
* @throws InvalidArgumentException |
|
1924
|
|
|
* @return void |
|
1925
|
|
|
*/ |
|
1926
|
|
|
public static function nullOrMaxLength($value, $max, $message = '') |
|
1927
|
|
|
{ |
|
1928
|
|
|
static::__callStatic('nullOrMaxLength', [$value, $max, $message]); |
|
1929
|
|
|
} |
|
1930
|
|
|
|
|
1931
|
|
|
/** |
|
1932
|
|
|
* @psalm-pure |
|
1933
|
|
|
* |
|
1934
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1935
|
|
|
* @param int|float $max |
|
1936
|
|
|
* @param string $message |
|
1937
|
|
|
* |
|
1938
|
|
|
* @throws InvalidArgumentException |
|
1939
|
|
|
* @return void |
|
1940
|
|
|
*/ |
|
1941
|
|
|
public static function allMaxLength($value, $max, $message = '') |
|
1942
|
|
|
{ |
|
1943
|
|
|
static::__callStatic('allMaxLength', [$value, $max, $message]); |
|
1944
|
|
|
} |
|
1945
|
|
|
|
|
1946
|
|
|
/** |
|
1947
|
|
|
* @psalm-pure |
|
1948
|
|
|
* |
|
1949
|
|
|
* @param string|null $value |
|
1950
|
|
|
* @param int|float $min |
|
1951
|
|
|
* @param int|float $max |
|
1952
|
|
|
* @param string $message |
|
1953
|
|
|
* |
|
1954
|
|
|
* @throws InvalidArgumentException |
|
1955
|
|
|
* @return void |
|
1956
|
|
|
*/ |
|
1957
|
|
|
public static function nullOrLengthBetween($value, $min, $max, $message = '') |
|
1958
|
|
|
{ |
|
1959
|
|
|
static::__callStatic('nullOrLengthBetween', [$value, $min, $max, $message]); |
|
1960
|
|
|
} |
|
1961
|
|
|
|
|
1962
|
|
|
/** |
|
1963
|
|
|
* @psalm-pure |
|
1964
|
|
|
* |
|
1965
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
1966
|
|
|
* @param int|float $min |
|
1967
|
|
|
* @param int|float $max |
|
1968
|
|
|
* @param string $message |
|
1969
|
|
|
* |
|
1970
|
|
|
* @throws InvalidArgumentException |
|
1971
|
|
|
* @return void |
|
1972
|
|
|
*/ |
|
1973
|
|
|
public static function allLengthBetween($value, $min, $max, $message = '') |
|
1974
|
|
|
{ |
|
1975
|
|
|
static::__callStatic('allLengthBetween', [$value, $min, $max, $message]); |
|
1976
|
|
|
} |
|
1977
|
|
|
|
|
1978
|
|
|
/** |
|
1979
|
|
|
* @param mixed $value |
|
1980
|
|
|
* @param string $message |
|
1981
|
|
|
* |
|
1982
|
|
|
* @throws InvalidArgumentException |
|
1983
|
|
|
* @return void |
|
1984
|
|
|
*/ |
|
1985
|
|
|
public static function nullOrFileExists($value, $message = '') |
|
1986
|
|
|
{ |
|
1987
|
|
|
static::__callStatic('nullOrFileExists', [$value, $message]); |
|
1988
|
|
|
} |
|
1989
|
|
|
|
|
1990
|
|
|
/** |
|
1991
|
|
|
* @param mixed $value |
|
1992
|
|
|
* @param string $message |
|
1993
|
|
|
* |
|
1994
|
|
|
* @throws InvalidArgumentException |
|
1995
|
|
|
* @return void |
|
1996
|
|
|
*/ |
|
1997
|
|
|
public static function allFileExists($value, $message = '') |
|
1998
|
|
|
{ |
|
1999
|
|
|
static::__callStatic('allFileExists', [$value, $message]); |
|
2000
|
|
|
} |
|
2001
|
|
|
|
|
2002
|
|
|
/** |
|
2003
|
|
|
* @param mixed $value |
|
2004
|
|
|
* @param string $message |
|
2005
|
|
|
* |
|
2006
|
|
|
* @throws InvalidArgumentException |
|
2007
|
|
|
* @return void |
|
2008
|
|
|
*/ |
|
2009
|
|
|
public static function nullOrFile($value, $message = '') |
|
2010
|
|
|
{ |
|
2011
|
|
|
static::__callStatic('nullOrFile', [$value, $message]); |
|
2012
|
|
|
} |
|
2013
|
|
|
|
|
2014
|
|
|
/** |
|
2015
|
|
|
* @param mixed $value |
|
2016
|
|
|
* @param string $message |
|
2017
|
|
|
* |
|
2018
|
|
|
* @throws InvalidArgumentException |
|
2019
|
|
|
* @return void |
|
2020
|
|
|
*/ |
|
2021
|
|
|
public static function allFile($value, $message = '') |
|
2022
|
|
|
{ |
|
2023
|
|
|
static::__callStatic('allFile', [$value, $message]); |
|
2024
|
|
|
} |
|
2025
|
|
|
|
|
2026
|
|
|
/** |
|
2027
|
|
|
* @param mixed $value |
|
2028
|
|
|
* @param string $message |
|
2029
|
|
|
* |
|
2030
|
|
|
* @throws InvalidArgumentException |
|
2031
|
|
|
* @return void |
|
2032
|
|
|
*/ |
|
2033
|
|
|
public static function nullOrDirectory($value, $message = '') |
|
2034
|
|
|
{ |
|
2035
|
|
|
static::__callStatic('nullOrDirectory', [$value, $message]); |
|
2036
|
|
|
} |
|
2037
|
|
|
|
|
2038
|
|
|
/** |
|
2039
|
|
|
* @param mixed $value |
|
2040
|
|
|
* @param string $message |
|
2041
|
|
|
* |
|
2042
|
|
|
* @throws InvalidArgumentException |
|
2043
|
|
|
* @return void |
|
2044
|
|
|
*/ |
|
2045
|
|
|
public static function allDirectory($value, $message = '') |
|
2046
|
|
|
{ |
|
2047
|
|
|
static::__callStatic('allDirectory', [$value, $message]); |
|
2048
|
|
|
} |
|
2049
|
|
|
|
|
2050
|
|
|
/** |
|
2051
|
|
|
* @param string|null $value |
|
2052
|
|
|
* @param string $message |
|
2053
|
|
|
* |
|
2054
|
|
|
* @throws InvalidArgumentException |
|
2055
|
|
|
* @return void |
|
2056
|
|
|
*/ |
|
2057
|
|
|
public static function nullOrReadable($value, $message = '') |
|
2058
|
|
|
{ |
|
2059
|
|
|
static::__callStatic('nullOrReadable', [$value, $message]); |
|
2060
|
|
|
} |
|
2061
|
|
|
|
|
2062
|
|
|
/** |
|
2063
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
2064
|
|
|
* @param string $message |
|
2065
|
|
|
* |
|
2066
|
|
|
* @throws InvalidArgumentException |
|
2067
|
|
|
* @return void |
|
2068
|
|
|
*/ |
|
2069
|
|
|
public static function allReadable($value, $message = '') |
|
2070
|
|
|
{ |
|
2071
|
|
|
static::__callStatic('allReadable', [$value, $message]); |
|
2072
|
|
|
} |
|
2073
|
|
|
|
|
2074
|
|
|
/** |
|
2075
|
|
|
* @param string|null $value |
|
2076
|
|
|
* @param string $message |
|
2077
|
|
|
* |
|
2078
|
|
|
* @throws InvalidArgumentException |
|
2079
|
|
|
* @return void |
|
2080
|
|
|
*/ |
|
2081
|
|
|
public static function nullOrWritable($value, $message = '') |
|
2082
|
|
|
{ |
|
2083
|
|
|
static::__callStatic('nullOrWritable', [$value, $message]); |
|
2084
|
|
|
} |
|
2085
|
|
|
|
|
2086
|
|
|
/** |
|
2087
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
2088
|
|
|
* @param string $message |
|
2089
|
|
|
* |
|
2090
|
|
|
* @throws InvalidArgumentException |
|
2091
|
|
|
* @return void |
|
2092
|
|
|
*/ |
|
2093
|
|
|
public static function allWritable($value, $message = '') |
|
2094
|
|
|
{ |
|
2095
|
|
|
static::__callStatic('allWritable', [$value, $message]); |
|
2096
|
|
|
} |
|
2097
|
|
|
|
|
2098
|
|
|
/** |
|
2099
|
|
|
* @psalm-assert class-string|null $value |
|
2100
|
|
|
* |
|
2101
|
|
|
* @param mixed $value |
|
2102
|
|
|
* @param string $message |
|
2103
|
|
|
* |
|
2104
|
|
|
* @throws InvalidArgumentException |
|
2105
|
|
|
* @return void |
|
2106
|
|
|
*/ |
|
2107
|
|
|
public static function nullOrClassExists($value, $message = '') |
|
2108
|
|
|
{ |
|
2109
|
|
|
static::__callStatic('nullOrClassExists', [$value, $message]); |
|
2110
|
|
|
} |
|
2111
|
|
|
|
|
2112
|
|
|
/** |
|
2113
|
|
|
* @psalm-assert iterable<class-string> $value |
|
2114
|
|
|
* |
|
2115
|
|
|
* @param mixed $value |
|
2116
|
|
|
* @param string $message |
|
2117
|
|
|
* |
|
2118
|
|
|
* @throws InvalidArgumentException |
|
2119
|
|
|
* @return void |
|
2120
|
|
|
*/ |
|
2121
|
|
|
public static function allClassExists($value, $message = '') |
|
2122
|
|
|
{ |
|
2123
|
|
|
static::__callStatic('allClassExists', [$value, $message]); |
|
2124
|
|
|
} |
|
2125
|
|
|
|
|
2126
|
|
|
/** |
|
2127
|
|
|
* @psalm-pure |
|
2128
|
|
|
* @psalm-template ExpectedType of object |
|
2129
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
2130
|
|
|
* @psalm-assert class-string<ExpectedType>|ExpectedType|null $value |
|
2131
|
|
|
* |
|
2132
|
|
|
* @param mixed $value |
|
2133
|
|
|
* @param string|object $class |
|
2134
|
|
|
* @param string $message |
|
2135
|
|
|
* |
|
2136
|
|
|
* @throws InvalidArgumentException |
|
2137
|
|
|
* @return void |
|
2138
|
|
|
*/ |
|
2139
|
|
|
public static function nullOrSubclassOf($value, $class, $message = '') |
|
2140
|
|
|
{ |
|
2141
|
|
|
static::__callStatic('nullOrSubclassOf', [$value, $class, $message]); |
|
2142
|
|
|
} |
|
2143
|
|
|
|
|
2144
|
|
|
/** |
|
2145
|
|
|
* @psalm-pure |
|
2146
|
|
|
* @psalm-template ExpectedType of object |
|
2147
|
|
|
* @psalm-param class-string<ExpectedType> $class |
|
2148
|
|
|
* @psalm-assert iterable<class-string<ExpectedType>|ExpectedType> $value |
|
2149
|
|
|
* |
|
2150
|
|
|
* @param mixed $value |
|
2151
|
|
|
* @param string|object $class |
|
2152
|
|
|
* @param string $message |
|
2153
|
|
|
* |
|
2154
|
|
|
* @throws InvalidArgumentException |
|
2155
|
|
|
* @return void |
|
2156
|
|
|
*/ |
|
2157
|
|
|
public static function allSubclassOf($value, $class, $message = '') |
|
2158
|
|
|
{ |
|
2159
|
|
|
static::__callStatic('allSubclassOf', [$value, $class, $message]); |
|
2160
|
|
|
} |
|
2161
|
|
|
|
|
2162
|
|
|
/** |
|
2163
|
|
|
* @psalm-assert class-string|null $value |
|
2164
|
|
|
* |
|
2165
|
|
|
* @param mixed $value |
|
2166
|
|
|
* @param string $message |
|
2167
|
|
|
* |
|
2168
|
|
|
* @throws InvalidArgumentException |
|
2169
|
|
|
* @return void |
|
2170
|
|
|
*/ |
|
2171
|
|
|
public static function nullOrInterfaceExists($value, $message = '') |
|
2172
|
|
|
{ |
|
2173
|
|
|
static::__callStatic('nullOrInterfaceExists', [$value, $message]); |
|
2174
|
|
|
} |
|
2175
|
|
|
|
|
2176
|
|
|
/** |
|
2177
|
|
|
* @psalm-assert iterable<class-string> $value |
|
2178
|
|
|
* |
|
2179
|
|
|
* @param mixed $value |
|
2180
|
|
|
* @param string $message |
|
2181
|
|
|
* |
|
2182
|
|
|
* @throws InvalidArgumentException |
|
2183
|
|
|
* @return void |
|
2184
|
|
|
*/ |
|
2185
|
|
|
public static function allInterfaceExists($value, $message = '') |
|
2186
|
|
|
{ |
|
2187
|
|
|
static::__callStatic('allInterfaceExists', [$value, $message]); |
|
2188
|
|
|
} |
|
2189
|
|
|
|
|
2190
|
|
|
/** |
|
2191
|
|
|
* @psalm-pure |
|
2192
|
|
|
* @psalm-template ExpectedType of object |
|
2193
|
|
|
* @psalm-param class-string<ExpectedType> $interface |
|
2194
|
|
|
* @psalm-assert class-string<ExpectedType>|null $value |
|
2195
|
|
|
* |
|
2196
|
|
|
* @param mixed $value |
|
2197
|
|
|
* @param mixed $interface |
|
2198
|
|
|
* @param string $message |
|
2199
|
|
|
* |
|
2200
|
|
|
* @throws InvalidArgumentException |
|
2201
|
|
|
* @return void |
|
2202
|
|
|
*/ |
|
2203
|
|
|
public static function nullOrImplementsInterface($value, $interface, $message = '') |
|
2204
|
|
|
{ |
|
2205
|
|
|
static::__callStatic('nullOrImplementsInterface', [$value, $interface, $message]); |
|
2206
|
|
|
} |
|
2207
|
|
|
|
|
2208
|
|
|
/** |
|
2209
|
|
|
* @psalm-pure |
|
2210
|
|
|
* @psalm-template ExpectedType of object |
|
2211
|
|
|
* @psalm-param class-string<ExpectedType> $interface |
|
2212
|
|
|
* @psalm-assert iterable<class-string<ExpectedType>> $value |
|
2213
|
|
|
* |
|
2214
|
|
|
* @param mixed $value |
|
2215
|
|
|
* @param mixed $interface |
|
2216
|
|
|
* @param string $message |
|
2217
|
|
|
* |
|
2218
|
|
|
* @throws InvalidArgumentException |
|
2219
|
|
|
* @return void |
|
2220
|
|
|
*/ |
|
2221
|
|
|
public static function allImplementsInterface($value, $interface, $message = '') |
|
2222
|
|
|
{ |
|
2223
|
|
|
static::__callStatic('allImplementsInterface', [$value, $interface, $message]); |
|
2224
|
|
|
} |
|
2225
|
|
|
|
|
2226
|
|
|
/** |
|
2227
|
|
|
* @psalm-pure |
|
2228
|
|
|
* @psalm-param class-string|object|null $classOrObject |
|
2229
|
|
|
* |
|
2230
|
|
|
* @param string|object|null $classOrObject |
|
2231
|
|
|
* @param mixed $property |
|
2232
|
|
|
* @param string $message |
|
2233
|
|
|
* |
|
2234
|
|
|
* @throws InvalidArgumentException |
|
2235
|
|
|
* @return void |
|
2236
|
|
|
*/ |
|
2237
|
|
|
public static function nullOrPropertyExists($classOrObject, $property, $message = '') |
|
2238
|
|
|
{ |
|
2239
|
|
|
static::__callStatic('nullOrPropertyExists', [$classOrObject, $property, $message]); |
|
2240
|
|
|
} |
|
2241
|
|
|
|
|
2242
|
|
|
/** |
|
2243
|
|
|
* @psalm-pure |
|
2244
|
|
|
* @psalm-param iterable<class-string|object> $classOrObject |
|
2245
|
|
|
* |
|
2246
|
|
|
* @param iterable<string|object> $classOrObject |
|
|
|
|
|
|
2247
|
|
|
* @param mixed $property |
|
2248
|
|
|
* @param string $message |
|
2249
|
|
|
* |
|
2250
|
|
|
* @throws InvalidArgumentException |
|
2251
|
|
|
* @return void |
|
2252
|
|
|
*/ |
|
2253
|
|
|
public static function allPropertyExists($classOrObject, $property, $message = '') |
|
2254
|
|
|
{ |
|
2255
|
|
|
static::__callStatic('allPropertyExists', [$classOrObject, $property, $message]); |
|
2256
|
|
|
} |
|
2257
|
|
|
|
|
2258
|
|
|
/** |
|
2259
|
|
|
* @psalm-pure |
|
2260
|
|
|
* @psalm-param class-string|object|null $classOrObject |
|
2261
|
|
|
* |
|
2262
|
|
|
* @param string|object|null $classOrObject |
|
2263
|
|
|
* @param mixed $property |
|
2264
|
|
|
* @param string $message |
|
2265
|
|
|
* |
|
2266
|
|
|
* @throws InvalidArgumentException |
|
2267
|
|
|
* @return void |
|
2268
|
|
|
*/ |
|
2269
|
|
|
public static function nullOrPropertyNotExists($classOrObject, $property, $message = '') |
|
2270
|
|
|
{ |
|
2271
|
|
|
static::__callStatic('nullOrPropertyNotExists', [$classOrObject, $property, $message]); |
|
2272
|
|
|
} |
|
2273
|
|
|
|
|
2274
|
|
|
/** |
|
2275
|
|
|
* @psalm-pure |
|
2276
|
|
|
* @psalm-param iterable<class-string|object> $classOrObject |
|
2277
|
|
|
* |
|
2278
|
|
|
* @param iterable<string|object> $classOrObject |
|
|
|
|
|
|
2279
|
|
|
* @param mixed $property |
|
2280
|
|
|
* @param string $message |
|
2281
|
|
|
* |
|
2282
|
|
|
* @throws InvalidArgumentException |
|
2283
|
|
|
* @return void |
|
2284
|
|
|
*/ |
|
2285
|
|
|
public static function allPropertyNotExists($classOrObject, $property, $message = '') |
|
2286
|
|
|
{ |
|
2287
|
|
|
static::__callStatic('allPropertyNotExists', [$classOrObject, $property, $message]); |
|
2288
|
|
|
} |
|
2289
|
|
|
|
|
2290
|
|
|
/** |
|
2291
|
|
|
* @psalm-pure |
|
2292
|
|
|
* @psalm-param class-string|object|null $classOrObject |
|
2293
|
|
|
* |
|
2294
|
|
|
* @param string|object|null $classOrObject |
|
2295
|
|
|
* @param mixed $method |
|
2296
|
|
|
* @param string $message |
|
2297
|
|
|
* |
|
2298
|
|
|
* @throws InvalidArgumentException |
|
2299
|
|
|
* @return void |
|
2300
|
|
|
*/ |
|
2301
|
|
|
public static function nullOrMethodExists($classOrObject, $method, $message = '') |
|
2302
|
|
|
{ |
|
2303
|
|
|
static::__callStatic('nullOrMethodExists', [$classOrObject, $method, $message]); |
|
2304
|
|
|
} |
|
2305
|
|
|
|
|
2306
|
|
|
/** |
|
2307
|
|
|
* @psalm-pure |
|
2308
|
|
|
* @psalm-param iterable<class-string|object> $classOrObject |
|
2309
|
|
|
* |
|
2310
|
|
|
* @param iterable<string|object> $classOrObject |
|
|
|
|
|
|
2311
|
|
|
* @param mixed $method |
|
2312
|
|
|
* @param string $message |
|
2313
|
|
|
* |
|
2314
|
|
|
* @throws InvalidArgumentException |
|
2315
|
|
|
* @return void |
|
2316
|
|
|
*/ |
|
2317
|
|
|
public static function allMethodExists($classOrObject, $method, $message = '') |
|
2318
|
|
|
{ |
|
2319
|
|
|
static::__callStatic('allMethodExists', [$classOrObject, $method, $message]); |
|
2320
|
|
|
} |
|
2321
|
|
|
|
|
2322
|
|
|
/** |
|
2323
|
|
|
* @psalm-pure |
|
2324
|
|
|
* @psalm-param class-string|object|null $classOrObject |
|
2325
|
|
|
* |
|
2326
|
|
|
* @param string|object|null $classOrObject |
|
2327
|
|
|
* @param mixed $method |
|
2328
|
|
|
* @param string $message |
|
2329
|
|
|
* |
|
2330
|
|
|
* @throws InvalidArgumentException |
|
2331
|
|
|
* @return void |
|
2332
|
|
|
*/ |
|
2333
|
|
|
public static function nullOrMethodNotExists($classOrObject, $method, $message = '') |
|
2334
|
|
|
{ |
|
2335
|
|
|
static::__callStatic('nullOrMethodNotExists', [$classOrObject, $method, $message]); |
|
2336
|
|
|
} |
|
2337
|
|
|
|
|
2338
|
|
|
/** |
|
2339
|
|
|
* @psalm-pure |
|
2340
|
|
|
* @psalm-param iterable<class-string|object> $classOrObject |
|
2341
|
|
|
* |
|
2342
|
|
|
* @param iterable<string|object> $classOrObject |
|
|
|
|
|
|
2343
|
|
|
* @param mixed $method |
|
2344
|
|
|
* @param string $message |
|
2345
|
|
|
* |
|
2346
|
|
|
* @throws InvalidArgumentException |
|
2347
|
|
|
* @return void |
|
2348
|
|
|
*/ |
|
2349
|
|
|
public static function allMethodNotExists($classOrObject, $method, $message = '') |
|
2350
|
|
|
{ |
|
2351
|
|
|
static::__callStatic('allMethodNotExists', [$classOrObject, $method, $message]); |
|
2352
|
|
|
} |
|
2353
|
|
|
|
|
2354
|
|
|
/** |
|
2355
|
|
|
* @psalm-pure |
|
2356
|
|
|
* |
|
2357
|
|
|
* @param array|null $array |
|
2358
|
|
|
* @param string|int $key |
|
2359
|
|
|
* @param string $message |
|
2360
|
|
|
* |
|
2361
|
|
|
* @throws InvalidArgumentException |
|
2362
|
|
|
* @return void |
|
2363
|
|
|
*/ |
|
2364
|
|
|
public static function nullOrKeyExists($array, $key, $message = '') |
|
2365
|
|
|
{ |
|
2366
|
|
|
static::__callStatic('nullOrKeyExists', [$array, $key, $message]); |
|
2367
|
|
|
} |
|
2368
|
|
|
|
|
2369
|
|
|
/** |
|
2370
|
|
|
* @psalm-pure |
|
2371
|
|
|
* |
|
2372
|
|
|
* @param iterable<array> $array |
|
|
|
|
|
|
2373
|
|
|
* @param string|int $key |
|
2374
|
|
|
* @param string $message |
|
2375
|
|
|
* |
|
2376
|
|
|
* @throws InvalidArgumentException |
|
2377
|
|
|
* @return void |
|
2378
|
|
|
*/ |
|
2379
|
|
|
public static function allKeyExists($array, $key, $message = '') |
|
2380
|
|
|
{ |
|
2381
|
|
|
static::__callStatic('allKeyExists', [$array, $key, $message]); |
|
2382
|
|
|
} |
|
2383
|
|
|
|
|
2384
|
|
|
/** |
|
2385
|
|
|
* @psalm-pure |
|
2386
|
|
|
* |
|
2387
|
|
|
* @param array|null $array |
|
2388
|
|
|
* @param string|int $key |
|
2389
|
|
|
* @param string $message |
|
2390
|
|
|
* |
|
2391
|
|
|
* @throws InvalidArgumentException |
|
2392
|
|
|
* @return void |
|
2393
|
|
|
*/ |
|
2394
|
|
|
public static function nullOrKeyNotExists($array, $key, $message = '') |
|
2395
|
|
|
{ |
|
2396
|
|
|
static::__callStatic('nullOrKeyNotExists', [$array, $key, $message]); |
|
2397
|
|
|
} |
|
2398
|
|
|
|
|
2399
|
|
|
/** |
|
2400
|
|
|
* @psalm-pure |
|
2401
|
|
|
* |
|
2402
|
|
|
* @param iterable<array> $array |
|
|
|
|
|
|
2403
|
|
|
* @param string|int $key |
|
2404
|
|
|
* @param string $message |
|
2405
|
|
|
* |
|
2406
|
|
|
* @throws InvalidArgumentException |
|
2407
|
|
|
* @return void |
|
2408
|
|
|
*/ |
|
2409
|
|
|
public static function allKeyNotExists($array, $key, $message = '') |
|
2410
|
|
|
{ |
|
2411
|
|
|
static::__callStatic('allKeyNotExists', [$array, $key, $message]); |
|
2412
|
|
|
} |
|
2413
|
|
|
|
|
2414
|
|
|
/** |
|
2415
|
|
|
* @psalm-pure |
|
2416
|
|
|
* @psalm-assert array-key|null $value |
|
2417
|
|
|
* |
|
2418
|
|
|
* @param mixed $value |
|
2419
|
|
|
* @param string $message |
|
2420
|
|
|
* |
|
2421
|
|
|
* @throws InvalidArgumentException |
|
2422
|
|
|
* @return void |
|
2423
|
|
|
*/ |
|
2424
|
|
|
public static function nullOrValidArrayKey($value, $message = '') |
|
2425
|
|
|
{ |
|
2426
|
|
|
static::__callStatic('nullOrValidArrayKey', [$value, $message]); |
|
2427
|
|
|
} |
|
2428
|
|
|
|
|
2429
|
|
|
/** |
|
2430
|
|
|
* @psalm-pure |
|
2431
|
|
|
* @psalm-assert iterable<array-key> $value |
|
2432
|
|
|
* |
|
2433
|
|
|
* @param mixed $value |
|
2434
|
|
|
* @param string $message |
|
2435
|
|
|
* |
|
2436
|
|
|
* @throws InvalidArgumentException |
|
2437
|
|
|
* @return void |
|
2438
|
|
|
*/ |
|
2439
|
|
|
public static function allValidArrayKey($value, $message = '') |
|
2440
|
|
|
{ |
|
2441
|
|
|
static::__callStatic('allValidArrayKey', [$value, $message]); |
|
2442
|
|
|
} |
|
2443
|
|
|
|
|
2444
|
|
|
/** |
|
2445
|
|
|
* @param Countable|array|null $array |
|
2446
|
|
|
* @param int $number |
|
2447
|
|
|
* @param string $message |
|
2448
|
|
|
* |
|
2449
|
|
|
* @throws InvalidArgumentException |
|
2450
|
|
|
* @return void |
|
2451
|
|
|
*/ |
|
2452
|
|
|
public static function nullOrCount($array, $number, $message = '') |
|
2453
|
|
|
{ |
|
2454
|
|
|
static::__callStatic('nullOrCount', [$array, $number, $message]); |
|
2455
|
|
|
} |
|
2456
|
|
|
|
|
2457
|
|
|
/** |
|
2458
|
|
|
* @param iterable<Countable|array> $array |
|
|
|
|
|
|
2459
|
|
|
* @param int $number |
|
2460
|
|
|
* @param string $message |
|
2461
|
|
|
* |
|
2462
|
|
|
* @throws InvalidArgumentException |
|
2463
|
|
|
* @return void |
|
2464
|
|
|
*/ |
|
2465
|
|
|
public static function allCount($array, $number, $message = '') |
|
2466
|
|
|
{ |
|
2467
|
|
|
static::__callStatic('allCount', [$array, $number, $message]); |
|
2468
|
|
|
} |
|
2469
|
|
|
|
|
2470
|
|
|
/** |
|
2471
|
|
|
* @param Countable|array|null $array |
|
2472
|
|
|
* @param int|float $min |
|
2473
|
|
|
* @param string $message |
|
2474
|
|
|
* |
|
2475
|
|
|
* @throws InvalidArgumentException |
|
2476
|
|
|
* @return void |
|
2477
|
|
|
*/ |
|
2478
|
|
|
public static function nullOrMinCount($array, $min, $message = '') |
|
2479
|
|
|
{ |
|
2480
|
|
|
static::__callStatic('nullOrMinCount', [$array, $min, $message]); |
|
2481
|
|
|
} |
|
2482
|
|
|
|
|
2483
|
|
|
/** |
|
2484
|
|
|
* @param iterable<Countable|array> $array |
|
|
|
|
|
|
2485
|
|
|
* @param int|float $min |
|
2486
|
|
|
* @param string $message |
|
2487
|
|
|
* |
|
2488
|
|
|
* @throws InvalidArgumentException |
|
2489
|
|
|
* @return void |
|
2490
|
|
|
*/ |
|
2491
|
|
|
public static function allMinCount($array, $min, $message = '') |
|
2492
|
|
|
{ |
|
2493
|
|
|
static::__callStatic('allMinCount', [$array, $min, $message]); |
|
2494
|
|
|
} |
|
2495
|
|
|
|
|
2496
|
|
|
/** |
|
2497
|
|
|
* @param Countable|array|null $array |
|
2498
|
|
|
* @param int|float $max |
|
2499
|
|
|
* @param string $message |
|
2500
|
|
|
* |
|
2501
|
|
|
* @throws InvalidArgumentException |
|
2502
|
|
|
* @return void |
|
2503
|
|
|
*/ |
|
2504
|
|
|
public static function nullOrMaxCount($array, $max, $message = '') |
|
2505
|
|
|
{ |
|
2506
|
|
|
static::__callStatic('nullOrMaxCount', [$array, $max, $message]); |
|
2507
|
|
|
} |
|
2508
|
|
|
|
|
2509
|
|
|
/** |
|
2510
|
|
|
* @param iterable<Countable|array> $array |
|
|
|
|
|
|
2511
|
|
|
* @param int|float $max |
|
2512
|
|
|
* @param string $message |
|
2513
|
|
|
* |
|
2514
|
|
|
* @throws InvalidArgumentException |
|
2515
|
|
|
* @return void |
|
2516
|
|
|
*/ |
|
2517
|
|
|
public static function allMaxCount($array, $max, $message = '') |
|
2518
|
|
|
{ |
|
2519
|
|
|
static::__callStatic('allMaxCount', [$array, $max, $message]); |
|
2520
|
|
|
} |
|
2521
|
|
|
|
|
2522
|
|
|
/** |
|
2523
|
|
|
* @param Countable|array|null $array |
|
2524
|
|
|
* @param int|float $min |
|
2525
|
|
|
* @param int|float $max |
|
2526
|
|
|
* @param string $message |
|
2527
|
|
|
* |
|
2528
|
|
|
* @throws InvalidArgumentException |
|
2529
|
|
|
* @return void |
|
2530
|
|
|
*/ |
|
2531
|
|
|
public static function nullOrCountBetween($array, $min, $max, $message = '') |
|
2532
|
|
|
{ |
|
2533
|
|
|
static::__callStatic('nullOrCountBetween', [$array, $min, $max, $message]); |
|
2534
|
|
|
} |
|
2535
|
|
|
|
|
2536
|
|
|
/** |
|
2537
|
|
|
* @param iterable<Countable|array> $array |
|
|
|
|
|
|
2538
|
|
|
* @param int|float $min |
|
2539
|
|
|
* @param int|float $max |
|
2540
|
|
|
* @param string $message |
|
2541
|
|
|
* |
|
2542
|
|
|
* @throws InvalidArgumentException |
|
2543
|
|
|
* @return void |
|
2544
|
|
|
*/ |
|
2545
|
|
|
public static function allCountBetween($array, $min, $max, $message = '') |
|
2546
|
|
|
{ |
|
2547
|
|
|
static::__callStatic('allCountBetween', [$array, $min, $max, $message]); |
|
2548
|
|
|
} |
|
2549
|
|
|
|
|
2550
|
|
|
/** |
|
2551
|
|
|
* @psalm-pure |
|
2552
|
|
|
* @psalm-assert list|null $array |
|
2553
|
|
|
* |
|
2554
|
|
|
* @param mixed $array |
|
2555
|
|
|
* @param string $message |
|
2556
|
|
|
* |
|
2557
|
|
|
* @throws InvalidArgumentException |
|
2558
|
|
|
* @return void |
|
2559
|
|
|
*/ |
|
2560
|
|
|
public static function nullOrIsList($array, $message = '') |
|
2561
|
|
|
{ |
|
2562
|
|
|
static::__callStatic('nullOrIsList', [$array, $message]); |
|
2563
|
|
|
} |
|
2564
|
|
|
|
|
2565
|
|
|
/** |
|
2566
|
|
|
* @psalm-pure |
|
2567
|
|
|
* @psalm-assert iterable<list> $array |
|
2568
|
|
|
* |
|
2569
|
|
|
* @param mixed $array |
|
2570
|
|
|
* @param string $message |
|
2571
|
|
|
* |
|
2572
|
|
|
* @throws InvalidArgumentException |
|
2573
|
|
|
* @return void |
|
2574
|
|
|
*/ |
|
2575
|
|
|
public static function allIsList($array, $message = '') |
|
2576
|
|
|
{ |
|
2577
|
|
|
static::__callStatic('allIsList', [$array, $message]); |
|
2578
|
|
|
} |
|
2579
|
|
|
|
|
2580
|
|
|
/** |
|
2581
|
|
|
* @psalm-pure |
|
2582
|
|
|
* @psalm-assert non-empty-list|null $array |
|
2583
|
|
|
* |
|
2584
|
|
|
* @param mixed $array |
|
2585
|
|
|
* @param string $message |
|
2586
|
|
|
* |
|
2587
|
|
|
* @throws InvalidArgumentException |
|
2588
|
|
|
* @return void |
|
2589
|
|
|
*/ |
|
2590
|
|
|
public static function nullOrIsNonEmptyList($array, $message = '') |
|
2591
|
|
|
{ |
|
2592
|
|
|
static::__callStatic('nullOrIsNonEmptyList', [$array, $message]); |
|
2593
|
|
|
} |
|
2594
|
|
|
|
|
2595
|
|
|
/** |
|
2596
|
|
|
* @psalm-pure |
|
2597
|
|
|
* @psalm-assert iterable<non-empty-list> $array |
|
2598
|
|
|
* |
|
2599
|
|
|
* @param mixed $array |
|
2600
|
|
|
* @param string $message |
|
2601
|
|
|
* |
|
2602
|
|
|
* @throws InvalidArgumentException |
|
2603
|
|
|
* @return void |
|
2604
|
|
|
*/ |
|
2605
|
|
|
public static function allIsNonEmptyList($array, $message = '') |
|
2606
|
|
|
{ |
|
2607
|
|
|
static::__callStatic('allIsNonEmptyList', [$array, $message]); |
|
2608
|
|
|
} |
|
2609
|
|
|
|
|
2610
|
|
|
/** |
|
2611
|
|
|
* @psalm-pure |
|
2612
|
|
|
* @psalm-template T |
|
2613
|
|
|
* @psalm-param mixed|array<T>|null $array |
|
2614
|
|
|
* @psalm-assert array<string, T>|null $array |
|
2615
|
|
|
* |
|
2616
|
|
|
* @param mixed $array |
|
2617
|
|
|
* @param string $message |
|
2618
|
|
|
* |
|
2619
|
|
|
* @throws InvalidArgumentException |
|
2620
|
|
|
* @return void |
|
2621
|
|
|
*/ |
|
2622
|
|
|
public static function nullOrIsMap($array, $message = '') |
|
2623
|
|
|
{ |
|
2624
|
|
|
static::__callStatic('nullOrIsMap', [$array, $message]); |
|
2625
|
|
|
} |
|
2626
|
|
|
|
|
2627
|
|
|
/** |
|
2628
|
|
|
* @psalm-pure |
|
2629
|
|
|
* @psalm-template T |
|
2630
|
|
|
* @psalm-param iterable<mixed|array<T>> $array |
|
2631
|
|
|
* @psalm-assert iterable<array<string, T>> $array |
|
2632
|
|
|
* |
|
2633
|
|
|
* @param mixed $array |
|
2634
|
|
|
* @param string $message |
|
2635
|
|
|
* |
|
2636
|
|
|
* @throws InvalidArgumentException |
|
2637
|
|
|
* @return void |
|
2638
|
|
|
*/ |
|
2639
|
|
|
public static function allIsMap($array, $message = '') |
|
2640
|
|
|
{ |
|
2641
|
|
|
static::__callStatic('allIsMap', [$array, $message]); |
|
2642
|
|
|
} |
|
2643
|
|
|
|
|
2644
|
|
|
/** |
|
2645
|
|
|
* @psalm-pure |
|
2646
|
|
|
* @psalm-template T |
|
2647
|
|
|
* @psalm-param mixed|array<T>|null $array |
|
2648
|
|
|
* |
|
2649
|
|
|
* @param mixed $array |
|
2650
|
|
|
* @param string $message |
|
2651
|
|
|
* |
|
2652
|
|
|
* @throws InvalidArgumentException |
|
2653
|
|
|
* @return void |
|
2654
|
|
|
*/ |
|
2655
|
|
|
public static function nullOrIsNonEmptyMap($array, $message = '') |
|
2656
|
|
|
{ |
|
2657
|
|
|
static::__callStatic('nullOrIsNonEmptyMap', [$array, $message]); |
|
2658
|
|
|
} |
|
2659
|
|
|
|
|
2660
|
|
|
/** |
|
2661
|
|
|
* @psalm-pure |
|
2662
|
|
|
* @psalm-template T |
|
2663
|
|
|
* @psalm-param iterable<mixed|array<T>> $array |
|
2664
|
|
|
* |
|
2665
|
|
|
* @param mixed $array |
|
2666
|
|
|
* @param string $message |
|
2667
|
|
|
* |
|
2668
|
|
|
* @throws InvalidArgumentException |
|
2669
|
|
|
* @return void |
|
2670
|
|
|
*/ |
|
2671
|
|
|
public static function allIsNonEmptyMap($array, $message = '') |
|
2672
|
|
|
{ |
|
2673
|
|
|
static::__callStatic('allIsNonEmptyMap', [$array, $message]); |
|
2674
|
|
|
} |
|
2675
|
|
|
|
|
2676
|
|
|
/** |
|
2677
|
|
|
* @psalm-pure |
|
2678
|
|
|
* |
|
2679
|
|
|
* @param string|null $value |
|
2680
|
|
|
* @param string $message |
|
2681
|
|
|
* |
|
2682
|
|
|
* @throws InvalidArgumentException |
|
2683
|
|
|
* @return void |
|
2684
|
|
|
*/ |
|
2685
|
|
|
public static function nullOrUuid($value, $message = '') |
|
2686
|
|
|
{ |
|
2687
|
|
|
static::__callStatic('nullOrUuid', [$value, $message]); |
|
2688
|
|
|
} |
|
2689
|
|
|
|
|
2690
|
|
|
/** |
|
2691
|
|
|
* @psalm-pure |
|
2692
|
|
|
* |
|
2693
|
|
|
* @param iterable<string> $value |
|
|
|
|
|
|
2694
|
|
|
* @param string $message |
|
2695
|
|
|
* |
|
2696
|
|
|
* @throws InvalidArgumentException |
|
2697
|
|
|
* @return void |
|
2698
|
|
|
*/ |
|
2699
|
|
|
public static function allUuid($value, $message = '') |
|
2700
|
|
|
{ |
|
2701
|
|
|
static::__callStatic('allUuid', [$value, $message]); |
|
2702
|
|
|
} |
|
2703
|
|
|
|
|
2704
|
|
|
/** |
|
2705
|
|
|
* @psalm-param class-string<Throwable> $class |
|
2706
|
|
|
* |
|
2707
|
|
|
* @param Closure|null $expression |
|
2708
|
|
|
* @param string $class |
|
2709
|
|
|
* @param string $message |
|
2710
|
|
|
* |
|
2711
|
|
|
* @throws InvalidArgumentException |
|
2712
|
|
|
* @return void |
|
2713
|
|
|
*/ |
|
2714
|
|
|
public static function nullOrThrows($expression, $class = 'Exception', $message = '') |
|
2715
|
|
|
{ |
|
2716
|
|
|
static::__callStatic('nullOrThrows', [$expression, $class, $message]); |
|
2717
|
|
|
} |
|
2718
|
|
|
|
|
2719
|
|
|
/** |
|
2720
|
|
|
* @psalm-param class-string<Throwable> $class |
|
2721
|
|
|
* |
|
2722
|
|
|
* @param iterable<Closure> $expression |
|
|
|
|
|
|
2723
|
|
|
* @param string $class |
|
2724
|
|
|
* @param string $message |
|
2725
|
|
|
* |
|
2726
|
|
|
* @throws InvalidArgumentException |
|
2727
|
|
|
* @return void |
|
2728
|
|
|
*/ |
|
2729
|
|
|
public static function allThrows($expression, $class = 'Exception', $message = '') |
|
2730
|
|
|
{ |
|
2731
|
|
|
static::__callStatic('allThrows', [$expression, $class, $message]); |
|
2732
|
|
|
} |
|
2733
|
|
|
} |
webmozart /
assert
Loading history...
This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types.