TTypeAssertExpressionType - Code Metrics - Inspection of "Add string parameter->isOK checks for v3 edm names..." - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d2e6ed...f00d96 )

by Alex

created 2017-05-10 16:19 UTC

TTypeAssertExpressionType B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	362
Duplicated Lines	2.49 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
wmc	44
lcom	1
cbo	7
dl	9
loc	362
rs	8.3396
c	0
b	0
f	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getType()	0	4	1
A	setType()	0	9	3
A	addToOperand()	9	9	2
A	issetOperand()	0	4	1
A	unsetOperand()	0	4	1
A	getOperand()	0	4	1
A	setOperand()	0	8	2
A	addToCollectionType()	0	9	2
A	issetCollectionType()	0	4	1
A	unsetCollectionType()	0	4	1
A	getCollectionType()	0	4	1
A	setCollectionType()	0	12	2
A	addToReferenceType()	0	9	2
A	issetReferenceType()	0	4	1
A	unsetReferenceType()	0	4	1
A	getReferenceType()	0	4	1
A	setReferenceType()	0	12	2
A	addToRowType()	0	9	2
A	issetRowType()	0	4	1
A	unsetRowType()	0	4	1
A	getRowType()	0	4	1
A	setRowType()	0	12	2
C	isOK()	0	43	12

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like TTypeAssertExpressionType often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use TTypeAssertExpressionType, and based on these observations, apply Extract Interface, too.

<?php

namespace AlgoWeb\ODataMetadata\MetadataV3\edm;

use AlgoWeb\ODataMetadata\IsOK;
use AlgoWeb\ODataMetadata\IsOKTraits\IsOKToolboxTrait;
use AlgoWeb\ODataMetadata\MetadataV3\edm\Groups\TFacetAttributesTrait;
use AlgoWeb\ODataMetadata\MetadataV3\edm\IsOKTraits\TWrappedFunctionTypeTrait;

/**
 * Class representing TTypeAssertExpressionType
 *
 *
 * XSD Type: TTypeAssertExpression
 */
class TTypeAssertExpressionType extends IsOK
{
    use TFacetAttributesTrait, TWrappedFunctionTypeTrait;
    /**
     * @property string $type
     */
    private $type = null;

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType[] $operand
     */
    private $operand = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType[] $collectionType
     */
    private $collectionType = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType[] $referenceType
     */
    private $referenceType = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType[] $rowType
     */
    private $rowType = [];

    /**
     * Gets as type
     *
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Sets a new type
     *
     * @param string $type
     * @return self
     */
    public function setType($type)
    {
        if (null != $type && !$this->isTWrappedFunctionTypeValid($type)) {
            $msg = "Type must be a valid TWrappedFunctionType";
            throw new \InvalidArgumentException($msg);
        }
        $this->type = $type;
        return $this;
    }

    /**
     * Adds as operand
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType $operand
     */
    public function addToOperand(TOperandType $operand)

    {
        $msg = null;
        if (!$operand->isOK($msg)) {
            throw new \InvalidArgumentException($msg);
        }
        $this->operand[] = $operand;
        return $this;
    }

    /**
     * isset operand
     *
     * @param scalar $index
     * @return boolean
     */
    public function issetOperand($index)
    {
        return isset($this->operand[$index]);
    }

    /**
     * unset operand
     *
     * @param scalar $index
     * @return void
     */
    public function unsetOperand($index)
    {
        unset($this->operand[$index]);
    }

    /**
     * Gets as operand
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType[]
     */
    public function getOperand()
    {
        return $this->operand;
    }

    /**
     * Sets a new operand
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType[] $operand
     * @return self
     */
    public function setOperand(array $operand)
    {
        if (!$this->isValidArrayOK($operand, '\AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType', $msg, 1)) {
            throw new \InvalidArgumentException($msg);
        }
        $this->operand = $operand;
        return $this;
    }

    /**
     * Adds as collectionType
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType $collectionType
     */
    public function addToCollectionType(TCollectionTypeType $collectionType)
    {
        $msg = null;
        if (!$collectionType->isOK($msg)) {
            throw new \InvalidArgumentException($msg);
        }
        $this->collectionType[] = $collectionType;
        return $this;
    }

    /**
     * isset collectionType
     *
     * @param scalar $index
     * @return boolean
     */
    public function issetCollectionType($index)
    {
        return isset($this->collectionType[$index]);
    }

    /**
     * unset collectionType
     *
     * @param scalar $index
     * @return void
     */
    public function unsetCollectionType($index)
    {
        unset($this->collectionType[$index]);
    }

    /**
     * Gets as collectionType
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType[]
     */
    public function getCollectionType()
    {
        return $this->collectionType;
    }

    /**
     * Sets a new collectionType
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType[] $collectionType
     * @return self
     */
    public function setCollectionType(array $collectionType)
    {
        if (!$this->isValidArrayOK(
            $collectionType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType',
            $msg
        )) {
            throw new \InvalidArgumentException($msg);
        }
        $this->collectionType = $collectionType;
        return $this;
    }

    /**
     * Adds as referenceType
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType $referenceType
     */
    public function addToReferenceType(TReferenceTypeType $referenceType)
    {
        $msg = null;
        if (!$referenceType->isOK($msg)) {
            throw new \InvalidArgumentException($msg);
        }
        $this->referenceType[] = $referenceType;
        return $this;
    }

    /**
     * isset referenceType
     *
     * @param scalar $index
     * @return boolean
     */
    public function issetReferenceType($index)
    {
        return isset($this->referenceType[$index]);
    }

    /**
     * unset referenceType
     *
     * @param scalar $index
     * @return void
     */
    public function unsetReferenceType($index)
    {
        unset($this->referenceType[$index]);
    }

    /**
     * Gets as referenceType
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType[]
     */
    public function getReferenceType()
    {
        return $this->referenceType;
    }

    /**
     * Sets a new referenceType
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType[] $referenceType
     * @return self
     */
    public function setReferenceType(array $referenceType)
    {
        if (!$this->isValidArrayOK(
            $referenceType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType',
            $msg
        )) {
            throw new \InvalidArgumentException($msg);
        }
        $this->referenceType = $referenceType;
        return $this;
    }

    /**
     * Adds as property
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType $property
     */
    public function addToRowType(TPropertyType $property)
    {
        $msg = null;
        if (!$property->isOK($msg)) {
            throw new \InvalidArgumentException($msg);
        }
        $this->rowType[] = $property;
        return $this;
    }

    /**
     * isset rowType
     *
     * @param scalar $index
     * @return boolean
     */
    public function issetRowType($index)
    {
        return isset($this->rowType[$index]);
    }

    /**
     * unset rowType
     *
     * @param scalar $index
     * @return void
     */
    public function unsetRowType($index)
    {
        unset($this->rowType[$index]);
    }

    /**
     * Gets as rowType
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType[]
     */
    public function getRowType()
    {
        return $this->rowType;
    }

    /**
     * Sets a new rowType
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType[] $rowType
     * @return self
     */
    public function setRowType(array $rowType)
    {
        if (!$this->isValidArrayOK(
            $rowType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType',
            $msg
        )) {
            throw new \InvalidArgumentException($msg);
        }
        $this->rowType = $rowType;
        return $this;
    }

    public function isOK(&$msg = null)
    {
        if (null != $this->type && !$this->isTWrappedFunctionTypeValid($this->type)) {
            $msg = "Type must be a valid TWrappedFunctionType";
            return false;
        }
        if (!$this->isValidArrayOK($this->operand, '\AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType', $msg, 1)) {
            return false;
        }
        if (!$this->isTFacetAttributesTraitValid($msg)) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->collectionType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->referenceType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->rowType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType',
            $msg
        )) {
            return false;
        }

        $count = (0 < count($this->collectionType) ? 1 : 0)
                 + (0 < count($this->referenceType) ? 1 : 0)
                 + (0 < count($this->rowType) ? 1 : 0);
        if (1 < $count) {
            $msg = "At most one of collection type, reference type and row type can be nonempty";
            return false;
        }
        return true;
    }
}


1		<?php
2
3		namespace AlgoWeb\ODataMetadata\MetadataV3\edm;
4
5		use AlgoWeb\ODataMetadata\IsOK;
6		use AlgoWeb\ODataMetadata\IsOKTraits\IsOKToolboxTrait;
7		use AlgoWeb\ODataMetadata\MetadataV3\edm\Groups\TFacetAttributesTrait;
8		use AlgoWeb\ODataMetadata\MetadataV3\edm\IsOKTraits\TWrappedFunctionTypeTrait;
9
10		/**
11		* Class representing TTypeAssertExpressionType
12		*
13		*
14		* XSD Type: TTypeAssertExpression
15		*/
16		class TTypeAssertExpressionType extends IsOK
17		{
18		use TFacetAttributesTrait, TWrappedFunctionTypeTrait;
19		/**
20		* @property string $type
21		*/
22		private $type = null;
23
24		/**
25		* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType[] $operand
26		*/
27		private $operand = [];
28
29		/**
30		* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType[] $collectionType
31		*/
32		private $collectionType = [];
33
34		/**
35		* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType[] $referenceType
36		*/
37		private $referenceType = [];
38
39		/**
40		* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType[] $rowType
41		*/
42		private $rowType = [];
43
44		/**
45		* Gets as type
46		*
47		* @return string
48		*/
49		public function getType()
50		{
51		return $this->type;
52		}
53
54		/**
55		* Sets a new type
56		*
57		* @param string $type
58		* @return self
59		*/
60		public function setType($type)
61		{
62		if (null != $type && !$this->isTWrappedFunctionTypeValid($type)) {
63		$msg = "Type must be a valid TWrappedFunctionType";
64		throw new \InvalidArgumentException($msg);
65		}
66		$this->type = $type;
67		return $this;
68		}
69
70		/**
71		* Adds as operand
72		*
73		* @return self
74		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType $operand
75		*/
76	View Code Duplication	public function addToOperand(TOperandType $operand)
		0 ignored issues – show Duplication introduced 2017-05-10 16:29 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...
77		{
78		$msg = null;
79		if (!$operand->isOK($msg)) {
80		throw new \InvalidArgumentException($msg);
81		}
82		$this->operand[] = $operand;
83		return $this;
84		}
85
86		/**
87		* isset operand
88		*
89		* @param scalar $index
90		* @return boolean
91		*/
92		public function issetOperand($index)
93		{
94		return isset($this->operand[$index]);
95		}
96
97		/**
98		* unset operand
99		*
100		* @param scalar $index
101		* @return void
102		*/
103		public function unsetOperand($index)
104		{
105		unset($this->operand[$index]);
106		}
107
108		/**
109		* Gets as operand
110		*
111		* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType[]
112		*/
113		public function getOperand()
114		{
115		return $this->operand;
116		}
117
118		/**
119		* Sets a new operand
120		*
121		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType[] $operand
122		* @return self
123		*/
124		public function setOperand(array $operand)
125		{
126		if (!$this->isValidArrayOK($operand, '\AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType', $msg, 1)) {
127		throw new \InvalidArgumentException($msg);
128		}
129		$this->operand = $operand;
130		return $this;
131		}
132
133		/**
134		* Adds as collectionType
135		*
136		* @return self
137		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType $collectionType
138		*/
139		public function addToCollectionType(TCollectionTypeType $collectionType)
140		{
141		$msg = null;
142		if (!$collectionType->isOK($msg)) {
143		throw new \InvalidArgumentException($msg);
144		}
145		$this->collectionType[] = $collectionType;
146		return $this;
147		}
148
149		/**
150		* isset collectionType
151		*
152		* @param scalar $index
153		* @return boolean
154		*/
155		public function issetCollectionType($index)
156		{
157		return isset($this->collectionType[$index]);
158		}
159
160		/**
161		* unset collectionType
162		*
163		* @param scalar $index
164		* @return void
165		*/
166		public function unsetCollectionType($index)
167		{
168		unset($this->collectionType[$index]);
169		}
170
171		/**
172		* Gets as collectionType
173		*
174		* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType[]
175		*/
176		public function getCollectionType()
177		{
178		return $this->collectionType;
179		}
180
181		/**
182		* Sets a new collectionType
183		*
184		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType[] $collectionType
185		* @return self
186		*/
187		public function setCollectionType(array $collectionType)
188		{
189		if (!$this->isValidArrayOK(
190		$collectionType,
191		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType',
192		$msg
193		)) {
194		throw new \InvalidArgumentException($msg);
195		}
196		$this->collectionType = $collectionType;
197		return $this;
198		}
199
200		/**
201		* Adds as referenceType
202		*
203		* @return self
204		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType $referenceType
205		*/
206		public function addToReferenceType(TReferenceTypeType $referenceType)
207		{
208		$msg = null;
209		if (!$referenceType->isOK($msg)) {
210		throw new \InvalidArgumentException($msg);
211		}
212		$this->referenceType[] = $referenceType;
213		return $this;
214		}
215
216		/**
217		* isset referenceType
218		*
219		* @param scalar $index
220		* @return boolean
221		*/
222		public function issetReferenceType($index)
223		{
224		return isset($this->referenceType[$index]);
225		}
226
227		/**
228		* unset referenceType
229		*
230		* @param scalar $index
231		* @return void
232		*/
233		public function unsetReferenceType($index)
234		{
235		unset($this->referenceType[$index]);
236		}
237
238		/**
239		* Gets as referenceType
240		*
241		* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType[]
242		*/
243		public function getReferenceType()
244		{
245		return $this->referenceType;
246		}
247
248		/**
249		* Sets a new referenceType
250		*
251		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType[] $referenceType
252		* @return self
253		*/
254		public function setReferenceType(array $referenceType)
255		{
256		if (!$this->isValidArrayOK(
257		$referenceType,
258		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType',
259		$msg
260		)) {
261		throw new \InvalidArgumentException($msg);
262		}
263		$this->referenceType = $referenceType;
264		return $this;
265		}
266
267		/**
268		* Adds as property
269		*
270		* @return self
271		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType $property
272		*/
273		public function addToRowType(TPropertyType $property)
274		{
275		$msg = null;
276		if (!$property->isOK($msg)) {
277		throw new \InvalidArgumentException($msg);
278		}
279		$this->rowType[] = $property;
280		return $this;
281		}
282
283		/**
284		* isset rowType
285		*
286		* @param scalar $index
287		* @return boolean
288		*/
289		public function issetRowType($index)
290		{
291		return isset($this->rowType[$index]);
292		}
293
294		/**
295		* unset rowType
296		*
297		* @param scalar $index
298		* @return void
299		*/
300		public function unsetRowType($index)
301		{
302		unset($this->rowType[$index]);
303		}
304
305		/**
306		* Gets as rowType
307		*
308		* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType[]
309		*/
310		public function getRowType()
311		{
312		return $this->rowType;
313		}
314
315		/**
316		* Sets a new rowType
317		*
318		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType[] $rowType
319		* @return self
320		*/
321		public function setRowType(array $rowType)
322		{
323		if (!$this->isValidArrayOK(
324		$rowType,
325		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType',
326		$msg
327		)) {
328		throw new \InvalidArgumentException($msg);
329		}
330		$this->rowType = $rowType;
331		return $this;
332		}
333
334		public function isOK(&$msg = null)
335		{
336		if (null != $this->type && !$this->isTWrappedFunctionTypeValid($this->type)) {
337		$msg = "Type must be a valid TWrappedFunctionType";
338		return false;
339		}
340		if (!$this->isValidArrayOK($this->operand, '\AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType', $msg, 1)) {
341		return false;
342		}
343		if (!$this->isTFacetAttributesTraitValid($msg)) {
344		return false;
345		}
346		if (!$this->isValidArrayOK(
347		$this->collectionType,
348		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TCollectionTypeType',
349		$msg
350		)) {
351		return false;
352		}
353		if (!$this->isValidArrayOK(
354		$this->referenceType,
355		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TReferenceTypeType',
356		$msg
357		)) {
358		return false;
359		}
360		if (!$this->isValidArrayOK(
361		$this->rowType,
362		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyType',
363		$msg
364		)) {
365		return false;
366		}
367
368		$count = (0 < count($this->collectionType) ? 1 : 0)
369		+ (0 < count($this->referenceType) ? 1 : 0)
370		+ (0 < count($this->rowType) ? 1 : 0);
371		if (1 < $count) {
372		$msg = "At most one of collection type, reference type and row type can be nonempty";
373		return false;
374		}
375		return true;
376		}
377		}
378

Algo-Web / ODataMetadata