File Object/TypeAssert.php | ξ ^ω^)ξ Teto PHP Objectsystem API

1:	<?php
2:
3:	namespace Teto\Object;
4:
5:	use function function_exists;
6:	use function get_class;
7:	use function get_debug_type;
8:	use function gettype;
9:	use function in_array;
10:	use function is_array;
11:	use function is_bool;
12:	use function is_callable;
13:	use function is_float;
14:	use function is_int;
15:	use function is_object;
16:	use function is_resource;
17:	use function is_scalar;
18:	use function is_string;
19:
20:	/**
21:	* Argument type assertion methods
22:	*
23:	* @author USAMI Kenta <tadsan@zonu.me>
24:	* @copyright 2016 Baguette HQ
25:	* @license http://www.apache.org/licenses/LICENSE-2.0
26:	*/
27:	trait TypeAssert
28:	{
29:	/**
30:	* Assert a value is expected typed
31:	*
32:	* @param string $expected_type
33:	* @param string $name Variable name (for error message)
34:	* @param mixed $value Received value
35:	* @param bool $is_nullable
36:	*/
37:	protected static function assertValue($expected_type, $name, $value, $is_nullable)
38:	{
39:	if ($is_nullable && $value === null) {
40:	return; // through
41:	} elseif ($expected_type === 'mixed') {
42:	return; // through
43:	} elseif ($expected_type === 'enum') {
44:	if (!isset(self::$enum_values) \|\| !isset(self::$enum_values[$name])) {
45:	new \LogicException("Doesn't set self::\$enum_values[$name]");
46:	}
47:
48:	if (in_array($value, self::$enum_values[$name], true)) {
49:	return;
50:	}
51:
52:	$expects = '[' . implode(', ', self::$enum_values[$name]) . ']';
53:	throw new \InvalidArgumentException(self::message($expects, $value, $name));
54:	} elseif (
55:	($expected_type === 'int' && is_int($value))
56:	\|\| ($expected_type === 'string' && is_string($value))
57:	\|\| ($expected_type === 'float' && is_float($value))
58:	\|\| ($expected_type === 'array' && is_array($value))
59:	\|\| ($expected_type === 'bool' && is_bool($value))
60:	\|\| ($expected_type === 'object' && is_object($value))
61:	\|\| ($expected_type === 'scalar' && is_scalar($value))
62:	\|\| ($expected_type === 'callable' && is_callable($value))
63:	\|\| ($expected_type === 'resource' && is_resource($value))
64:	) {
65:	return;
66:	} elseif (is_object($value) && $value instanceof $expected_type) {
67:	return;
68:	}
69:
70:	throw new \InvalidArgumentException(self::message($expected_type, $value, $name));
71:	}
72:
73:	/**
74:	* Assert a value is integer
75:	*
76:	* @param mixed $value Received value
77:	* @param string $name Variable name (for error message)
78:	* @throws \InvalidArgumentException
79:	*/
80:	protected static function assertInt($value, $name = null)
81:	{
82:	if (!is_int($value)) {
83:	throw new \InvalidArgumentException(self::message('int', $value, $name));
84:	}
85:	}
86:
87:	/**
88:	* Assert a value is string
89:	*
90:	* @param mixed $value Received value
91:	* @param string $name Variable name (for error message)
92:	* @throws \InvalidArgumentException
93:	*/
94:	protected static function assertString($value, $name = null)
95:	{
96:	if (!is_string($value)) {
97:	throw new \InvalidArgumentException(self::message('string', $value, $name));
98:	}
99:	}
100:
101:	/**
102:	* Assert a value is array or array like object (that inplements ArrayAccess)
103:	*
104:	* @param mixed $value Received value
105:	* @param string $name Variable name (for error message)
106:	* @throws \InvalidArgumentException
107:	* @see http://php.net/manual/class.arrayaccess.php
108:	*/
109:	protected static function assertArrayOrObject($value, $name = null)
110:	{
111:	if (!is_array($value) && !$value instanceof \ArrayAccess) {
112:	throw new \InvalidArgumentException(self::message('array or ArrayAccess', $value, $name));
113:	}
114:	}
115:
116:	/**
117:	* Assert a value is instance of $class
118:	*
119:	* @param mixed $value Received value
120:	* @param string $class Class name
121:	* @param string $name Variable name (for error message)
122:	* @throws \InvalidArgumentException
123:	*/
124:	protected static function assertInstanceOf($value, $class, $name = null)
125:	{
126:	if (!$value instanceof $class) {
127:	throw new \InvalidArgumentException(self::message($class, $value, $name));
128:	}
129:	}
130:
131:	/**
132:	* @param string $expected_type
133:	* @param mixed $value
134:	* @param string\|null $name
135:	* @return string
136:	*/
137:	private static function message($expected_type, $value, $name)
138:	{
139:	if (function_exists('get_debug_type')) {
140:	$type = get_debug_type($value);
141:	} else {
142:	$type = is_object($value) ? get_class($value) : gettype($value);
143:	}
144:
145:	$vars = ($name === null) ? $type : "$name as $type";
146:
147:	return "got \${$vars} (expects {$expected_type})";
148:	}
149:	}
150:

Namespaces

Classes

Interfaces

Traits