AbstractJsonDeserializeObject::getRaw() - Code Metrics - Inspection of "fix(Collection): fix add function for collection" - commercetools/commercetools-php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — develop (993cdd)

by Jens

created 2016-02-18 13:27 UTC

AbstractJsonDeserializeObject::getRaw() A

↳ Parent: AbstractJsonDeserializeObject

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	2
eloc	2
nc	2
nop	2
crap	2

<?php
/**
 * @author @jayS-de <[email protected]>
 */

namespace Commercetools\Core\Model\Common;

/**
 * @package Commercetools\Core\Model\Common
 */
abstract class AbstractJsonDeserializeObject implements JsonDeserializeInterface, ObjectTreeInterface
{
    use ObjectTreeTrait;

    const JSON_DESERIALIZE_INTERFACE = 'Commercetools\Core\Model\Common\JsonDeserializeInterface';
    const TYPEABLE_INTERFACE = '\Commercetools\Core\Model\Common\TypeableInterface';

    abstract protected function initialize($field);

    protected $rawData = [];
    protected $typeData = [];
    protected $initialized = [];

    /**
     * @param array $data
     * @param Context|callable $context
     */
    public function __construct(array $data = [], $context = null)
    {
        $this->setContext($context);
        if (!is_null($data)) {
            $this->rawData = $this->typeData = $data;
        }
    }

    protected static $primitives = [
        'bool' => 'is_bool',
        'int' => 'is_int',
        'string' => 'is_string',
        'float' => 'is_float',
        'array' => 'is_array'
    ];

    /**
     * @var bool[]
     */
    protected static $interfaces = [];

    public function __sleep()
    {
        return array_diff(array_keys(get_object_vars($this)), ['context']);
    }

    /**
     * @param $type
     * @param $interfaceName
     * @return bool
     * @internal
     */
    protected function hasInterface($type, $interfaceName)
    {
        $interfaceName = trim($interfaceName, '\\');
        $cacheKey = $interfaceName . '-' . $type;
        if (!isset(static::$interfaces[$cacheKey])) {
            $interface = false;
            if ($this->isPrimitive($type) === false
                && isset(class_implements($type)[$interfaceName])
            ) {
                $interface = true;
            }
            static::$interfaces[$cacheKey] = $interface;
        }
        return static::$interfaces[$cacheKey];
    }

    /**
     * @param $type
     * @return string|false
     * @internal
     */
    protected function isPrimitive($type)
    {
        if (!isset(static::$primitives[$type])) {
            return false;
        }

        return static::$primitives[$type];
    }

    /**
     * @param string|bool $type
     * @param mixed $value
     * @return bool
     */
    protected function isValidType($type, $value)
    {
        return !is_string($type) || is_null($value) || $this->isType($type, $value);
    }

    /**
     * @param string $type
     * @param mixed $value
     * @return bool
     * @internal
     */
    protected function isType($type, $value)
    {
        if ($typeFunction = $this->isPrimitive($type)) {
            return $typeFunction($value);
        }
        return $value instanceof $type;
    }

    /**
     * @param $value
     * @return bool
     */
    protected function isDeserializable($value)
    {
        return (is_object($value) && $this->hasInterface(get_class($value), static::JSON_DESERIALIZE_INTERFACE));
    }

    /**
     * @param $type
     * @return bool
     */
    protected function isDeserializableType($type)

    {
        if (!is_string($type) || empty($type)) {
            return false;
        }
        return $this->hasInterface($type, static::JSON_DESERIALIZE_INTERFACE);
    }

    protected function isTypeableType($type)

    {
        if (!is_string($type) || empty($type)) {
            return false;
        }
        return $this->hasInterface($type, static::TYPEABLE_INTERFACE);
    }

    protected function getTyped($offset)
    {
        if (!isset($this->initialized[$offset])) {
            $this->initialize($offset);
        }
        if (array_key_exists($offset, $this->typeData)) {
            return $this->typeData[$offset];
        }
        return $this->rawData[$offset];
    }

    /**
     * @param array $rawData
     * @internal
     * @return $this
     */
    public function setRawData(array $rawData)
    {
        $this->rawData = $this->typeData = $rawData;

        return $this;
    }

    /**
     * @param $field
     * @param $default
     * @return mixed
     */
    protected function getRaw($field, $default = null)
    {
        return isset($this->rawData[$field])? $this->rawData[$field]: $default;
    }

    /**
     * (PHP 5 &gt;= 5.4.0)<br/>
     * Specify data which should be serialized to JSON
     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
     * @return mixed data which can be serialized by <b>json_encode</b>,
     * which is a value of any type other than a resource.
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * @return array
     */
    public function toArray()
    {
        $data = array_filter($this->typeData, function ($value) {
            return !is_null($value);
        });
        $data = array_map(
            function ($value) {
                if ($value instanceof JsonDeserializeInterface) {
                    return $value->toArray();
                }
                return $value;
            },
            $data
        );
        return $data;
    }

    /**
     * @param array $data
     * @param Context|callable $context
     * @return static
     */
    public static function fromArray(array $data, $context = null)
    {
        return new static($data, $context);
    }

    /**
     * @param Context|callable $context
     * @return static
     */
    final public static function of($context = null)
    {
        return new static([], $context);
    }
}


1			<?php
2			/**
3			* @author @jayS-de <[email protected]>
4			*/
5
6			namespace Commercetools\Core\Model\Common;
7
8			/**
9			* @package Commercetools\Core\Model\Common
10			*/
11			abstract class AbstractJsonDeserializeObject implements JsonDeserializeInterface, ObjectTreeInterface
12			{
13			use ObjectTreeTrait;
14
15			const JSON_DESERIALIZE_INTERFACE = 'Commercetools\Core\Model\Common\JsonDeserializeInterface';
16			const TYPEABLE_INTERFACE = '\Commercetools\Core\Model\Common\TypeableInterface';
17
18			abstract protected function initialize($field);
19
20			protected $rawData = [];
21			protected $typeData = [];
22			protected $initialized = [];
23
24			/**
25			* @param array $data
26			* @param Context\|callable $context
27			*/
28	816		public function __construct(array $data = [], $context = null)
29			{
30	816		$this->setContext($context);
31	816		if (!is_null($data)) {
32	816		$this->rawData = $this->typeData = $data;
33	816		}
34	816		}
35
36			protected static $primitives = [
37			'bool' => 'is_bool',
38			'int' => 'is_int',
39			'string' => 'is_string',
40			'float' => 'is_float',
41			'array' => 'is_array'
42			];
43
44			/**
45			* @var bool[]
46			*/
47			protected static $interfaces = [];
48
49			public function __sleep()
50			{
51			return array_diff(array_keys(get_object_vars($this)), ['context']);
52			}
53
54			/**
55			* @param $type
56			* @param $interfaceName
57			* @return bool
58			* @internal
59			*/
60	152		protected function hasInterface($type, $interfaceName)
61			{
62	152		$interfaceName = trim($interfaceName, '\\');
63	152		$cacheKey = $interfaceName . '-' . $type;
64	152		if (!isset(static::$interfaces[$cacheKey])) {
65	46		$interface = false;
66	46		if ($this->isPrimitive($type) === false
67	46		&& isset(class_implements($type)[$interfaceName])
68	46		) {
69	38		$interface = true;
70	38		}
71	46		static::$interfaces[$cacheKey] = $interface;
72	46		}
73	152		return static::$interfaces[$cacheKey];
74			}
75
76			/**
77			* @param $type
78			* @return string\|false
79			* @internal
80			*/
81	441		protected function isPrimitive($type)
82			{
83	441		if (!isset(static::$primitives[$type])) {
84	178		return false;
85			}
86
87	398		return static::$primitives[$type];
88			}
89
90			/**
91			* @param string\|bool $type
92			* @param mixed $value
93			* @return bool
94			*/
95	432		protected function isValidType($type, $value)
96			{
97	432		return !is_string($type) \|\| is_null($value) \|\| $this->isType($type, $value);
98			}
99
100			/**
101			* @param string $type
102			* @param mixed $value
103			* @return bool
104			* @internal
105			*/
106	428		protected function isType($type, $value)
107			{
108	428		if ($typeFunction = $this->isPrimitive($type)) {
109	396		return $typeFunction($value);
110			}
111	162		return $value instanceof $type;
112			}
113
114			/**
115			* @param $value
116			* @return bool
117			*/
118			protected function isDeserializable($value)
119			{
120			return (is_object($value) && $this->hasInterface(get_class($value), static::JSON_DESERIALIZE_INTERFACE));
121			}
122
123			/**
124			* @param $type
125			* @return bool
126			*/
127	153	View Code Duplication	protected function isDeserializableType($type)
			0 ignored issues – show Duplication introduced 2015-12-07 15:55 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
128			{
129	153		if (!is_string($type) \|\| empty($type)) {
130	2		return false;
131			}
132	152		return $this->hasInterface($type, static::JSON_DESERIALIZE_INTERFACE);
133			}
134
135	141	View Code Duplication	protected function isTypeableType($type)
			0 ignored issues – show Duplication introduced 2015-12-07 15:55 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
136			{
137	141		if (!is_string($type) \|\| empty($type)) {
138	2		return false;
139			}
140	140		return $this->hasInterface($type, static::TYPEABLE_INTERFACE);
141			}
142
143	214		protected function getTyped($offset)
144			{
145	214		if (!isset($this->initialized[$offset])) {
146	155		$this->initialize($offset);
147	155		}
148	214		if (array_key_exists($offset, $this->typeData)) {
149	214		return $this->typeData[$offset];
150			}
151			return $this->rawData[$offset];
152			}
153
154			/**
155			* @param array $rawData
156			* @internal
157			* @return $this
158			*/
159	10		public function setRawData(array $rawData)
160			{
161	10		$this->rawData = $this->typeData = $rawData;
162
163	10		return $this;
164			}
165
166			/**
167			* @param $field
168			* @param $default
169			* @return mixed
170			*/
171	152		protected function getRaw($field, $default = null)
172			{
173	152		return isset($this->rawData[$field])? $this->rawData[$field]: $default;
174			}
175
176			/**
177			* (PHP 5 >= 5.4.0)<br/>
178			* Specify data which should be serialized to JSON
179			* @link http://php.net/manual/en/jsonserializable.jsonserialize.php
180			* @return mixed data which can be serialized by <b>json_encode</b>,
181			* which is a value of any type other than a resource.
182			*/
183	82		public function jsonSerialize()
184			{
185	82		return $this->toArray();
186			}
187
188			/**
189			* @return array
190			*/
191	86		public function toArray()
192			{
193			$data = array_filter($this->typeData, function ($value) {
194	84		return !is_null($value);
195	86		});
196	86		$data = array_map(
197	86		function ($value) {
198	84		if ($value instanceof JsonDeserializeInterface) {
199	49		return $value->toArray();
200			}
201	71		return $value;
202	86		},
203			$data
204	86		);
205	86		return $data;
206			}
207
208			/**
209			* @param array $data
210			* @param Context\|callable $context
211			* @return static
212			*/
213	289		public static function fromArray(array $data, $context = null)
214			{
215	289		return new static($data, $context);
216			}
217
218			/**
219			* @param Context\|callable $context
220			* @return static
221			*/
222	587		final public static function of($context = null)
223			{
224	587		return new static([], $context);
225			}
226			}
227

commercetools / commercetools-php-sdk

Branch — develop (993cdd)

AbstractJsonDeserializeObject::getRaw() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like