TComplexTypeMappingType - Code Metrics - Inspection of "Cleaned up code for readability (#113)" - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1b7170...9fa28d )

by Alex

created 2017-06-21 13:11 UTC

TComplexTypeMappingType B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	344
Duplicated Lines	26.74 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	40
lcom	1
cbo	4
dl	92
loc	344
rs	8.2608
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	getTypeName()	0	4	1
A	setTypeName()	11	11	3
A	getIsPartial()	0	4	1
A	setIsPartial()	0	5	1
A	addToScalarProperty()	9	9	2
A	issetScalarProperty()	0	4	1
A	unsetScalarProperty()	0	4	1
A	getScalarProperty()	0	4	1
A	setScalarProperty()	16	17	3
A	addToComplexProperty()	9	9	2
A	issetComplexProperty()	0	4	1
A	unsetComplexProperty()	0	4	1
A	getComplexProperty()	0	4	1
A	setComplexProperty()	16	17	3
A	addToCondition()	9	9	2
A	issetCondition()	0	4	1
A	unsetCondition()	0	4	1
A	getCondition()	0	4	1
A	setCondition()	16	17	3
C	isOK()	6	49	10

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 TComplexTypeMappingType 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 TComplexTypeMappingType, and based on these observations, apply Extract Interface, too.

<?php

namespace AlgoWeb\ODataMetadata\MetadataV3\mapping\cs;

use AlgoWeb\ODataMetadata\IsOK;

/**
 * Class representing TComplexTypeMappingType
 *
 * Type for Complex Type mapping element
 *
 * XSD Type: TComplexTypeMapping
 */
class TComplexTypeMappingType extends IsOK
{

    /**
     * @property string $typeName
     */
    private $typeName = null;

    /**
     * @property boolean $isPartial
     */
    private $isPartial = null;

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType[] $scalarProperty
     */
    private $scalarProperty = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType[] $complexProperty
     */
    private $complexProperty = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType[] $condition
     */
    private $condition = [];

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

    /**
     * Sets a new typeName
     *
     * @param  string $typeName
     * @return self
     */
    public function setTypeName($typeName)

    {
        if (null != $typeName) {
            if (!$this->isStringNotNullOrEmpty($typeName)) {
                $msg = 'Type name cannot be empty';
                throw new \InvalidArgumentException($msg);
            }
        }
        $this->typeName = $typeName;
        return $this;
    }

    /**
     * Gets as isPartial
     *
     * @return boolean
     */
    public function getIsPartial()
    {
        return $this->isPartial;
    }

    /**
     * Sets a new isPartial
     *
     * @param  boolean $isPartial
     * @return self
     */
    public function setIsPartial($isPartial)
    {
        $this->isPartial = $isPartial;
        return $this;
    }

    /**
     * Adds as scalarProperty
     *
     * @return self
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType $scalarProperty
     */
    public function addToScalarProperty(TScalarPropertyType $scalarProperty)

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

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

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

    /**
     * Gets as scalarProperty
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType[]
     */
    public function getScalarProperty()
    {
        return $this->scalarProperty;
    }

    /**
     * Sets a new scalarProperty
     *
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType[] $scalarProperty
     * @return self
     */
    public function setScalarProperty(array $scalarProperty)

    {
        $msg = null;
        // if other arrays are empty, then the array we're assigning must not be empty
        $count = count($this->complexProperty) + count($this->condition);
        if (!$this->isValidArrayOK(
            $scalarProperty,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType',
            $msg,
            0 < $count ? 0 : 1
        )
        ) {
            throw new \InvalidArgumentException($msg);
        }
        $this->scalarProperty = $scalarProperty;
        return $this;
    }

    /**
     * Adds as complexProperty
     *
     * @return self
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType $complexProperty
     */
    public function addToComplexProperty(TComplexPropertyType $complexProperty)

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

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

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

    /**
     * Gets as complexProperty
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType[]
     */
    public function getComplexProperty()
    {
        return $this->complexProperty;
    }

    /**
     * Sets a new complexProperty
     *
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType[] $complexProperty
     * @return self
     */
    public function setComplexProperty(array $complexProperty)

    {
        $msg = null;
        // if other arrays are empty, then the array we're assigning must not be empty
        $count = count($this->scalarProperty) + count($this->condition);
        if (!$this->isValidArrayOK(
            $complexProperty,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType',
            $msg,
            0 < $count ? 0 : 1
        )
        ) {
            throw new \InvalidArgumentException($msg);
        }
        $this->complexProperty = $complexProperty;
        return $this;
    }

    /**
     * Adds as condition
     *
     * @return self
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType $condition
     */
    public function addToCondition(TConditionType $condition)

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

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

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

    /**
     * Gets as condition
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType[]
     */
    public function getCondition()
    {
        return $this->condition;
    }

    /**
     * Sets a new condition
     *
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType[] $condition
     * @return self
     */
    public function setCondition(array $condition)

    {
        $msg = null;
        // if other arrays are empty, then the array we're assigning must not be empty
        $count = count($this->scalarProperty) + count($this->complexProperty);
        if (!$this->isValidArrayOK(
            $condition,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType',
            $msg,
            0 < $count ? 0 : 1
        )
        ) {
            throw new \InvalidArgumentException($msg);
        }
        $this->condition = $condition;
        return $this;
    }

    public function isOK(&$msg = null)
    {
        if (null != $this->typeName) {

            if (!$this->isStringNotNullOrEmpty($this->typeName)) {
                $msg = 'Type name cannot be empty';
                return false;
            }
        }
        $count = count($this->scalarProperty) + count($this->complexProperty) + count($this->condition);
        if (1 > $count) {
            $msg = "Cannot have all arrays empty";
            return false;
        }

        if (!$this->isValidArray(
            $this->scalarProperty,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType'
        )
        ) {
            $msg = "Scalar property array not a valid array";
            return false;
        }
        if (!$this->isChildArrayOK($this->scalarProperty, $msg)) {
            return false;
        }
        if (!$this->isValidArray(
            $this->complexProperty,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType'
        )
        ) {
            $msg = "Complex property array not a valid array";
            return false;
        }
        if (!$this->isChildArrayOK($this->complexProperty, $msg)) {
            return false;
        }
        if (!$this->isValidArray(
            $this->condition,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType'
        )
        ) {
            $msg = "Condition array not a valid array";
            return false;
        }
        if (!$this->isChildArrayOK($this->condition, $msg)) {
            return false;
        }
        return true;
    }
}


1		<?php
2
3		namespace AlgoWeb\ODataMetadata\MetadataV3\mapping\cs;
4
5		use AlgoWeb\ODataMetadata\IsOK;
6
7		/**
8		* Class representing TComplexTypeMappingType
9		*
10		* Type for Complex Type mapping element
11		*
12		* XSD Type: TComplexTypeMapping
13		*/
14		class TComplexTypeMappingType extends IsOK
15		{
16
17		/**
18		* @property string $typeName
19		*/
20		private $typeName = null;
21
22		/**
23		* @property boolean $isPartial
24		*/
25		private $isPartial = null;
26
27		/**
28		* @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType[] $scalarProperty
29		*/
30		private $scalarProperty = [];
31
32		/**
33		* @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType[] $complexProperty
34		*/
35		private $complexProperty = [];
36
37		/**
38		* @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType[] $condition
39		*/
40		private $condition = [];
41
42		/**
43		* Gets as typeName
44		*
45		* @return string
46		*/
47		public function getTypeName()
48		{
49		return $this->typeName;
50		}
51
52		/**
53		* Sets a new typeName
54		*
55		* @param string $typeName
56		* @return self
57		*/
58	View Code Duplication	public function setTypeName($typeName)
		0 ignored issues – show Duplication introduced 2017-05-09 00:18 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...
59		{
60		if (null != $typeName) {
61		if (!$this->isStringNotNullOrEmpty($typeName)) {
62		$msg = 'Type name cannot be empty';
63		throw new \InvalidArgumentException($msg);
64		}
65		}
66		$this->typeName = $typeName;
67		return $this;
68		}
69
70		/**
71		* Gets as isPartial
72		*
73		* @return boolean
74		*/
75		public function getIsPartial()
76		{
77		return $this->isPartial;
78		}
79
80		/**
81		* Sets a new isPartial
82		*
83		* @param boolean $isPartial
84		* @return self
85		*/
86		public function setIsPartial($isPartial)
87		{
88		$this->isPartial = $isPartial;
89		return $this;
90		}
91
92		/**
93		* Adds as scalarProperty
94		*
95		* @return self
96		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType $scalarProperty
97		*/
98	View Code Duplication	public function addToScalarProperty(TScalarPropertyType $scalarProperty)
		0 ignored issues – show Duplication introduced 2017-05-08 12:31 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...
99		{
100		$msg = null;
101		if (!$scalarProperty->isOK($msg)) {
102		throw new \InvalidArgumentException($msg);
103		}
104		$this->scalarProperty[] = $scalarProperty;
105		return $this;
106		}
107
108		/**
109		* isset scalarProperty
110		*
111		* @param scalar $index
112		* @return boolean
113		*/
114		public function issetScalarProperty($index)
115		{
116		return isset($this->scalarProperty[$index]);
117		}
118
119		/**
120		* unset scalarProperty
121		*
122		* @param scalar $index
123		* @return void
124		*/
125		public function unsetScalarProperty($index)
126		{
127		unset($this->scalarProperty[$index]);
128		}
129
130		/**
131		* Gets as scalarProperty
132		*
133		* @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType[]
134		*/
135		public function getScalarProperty()
136		{
137		return $this->scalarProperty;
138		}
139
140		/**
141		* Sets a new scalarProperty
142		*
143		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType[] $scalarProperty
144		* @return self
145		*/
146	View Code Duplication	public function setScalarProperty(array $scalarProperty)
		0 ignored issues – show Duplication introduced 2017-05-09 05:36 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...
147		{
148		$msg = null;
149		// if other arrays are empty, then the array we're assigning must not be empty
150		$count = count($this->complexProperty) + count($this->condition);
151		if (!$this->isValidArrayOK(
152		$scalarProperty,
153		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType',
154		$msg,
155		0 < $count ? 0 : 1
156		)
157		) {
158		throw new \InvalidArgumentException($msg);
159		}
160		$this->scalarProperty = $scalarProperty;
161		return $this;
162		}
163
164		/**
165		* Adds as complexProperty
166		*
167		* @return self
168		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType $complexProperty
169		*/
170	View Code Duplication	public function addToComplexProperty(TComplexPropertyType $complexProperty)
		0 ignored issues – show Duplication introduced 2017-05-08 12:31 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...
171		{
172		$msg = null;
173		if (!$complexProperty->isOK($msg)) {
174		throw new \InvalidArgumentException($msg);
175		}
176		$this->complexProperty[] = $complexProperty;
177		return $this;
178		}
179
180		/**
181		* isset complexProperty
182		*
183		* @param scalar $index
184		* @return boolean
185		*/
186		public function issetComplexProperty($index)
187		{
188		return isset($this->complexProperty[$index]);
189		}
190
191		/**
192		* unset complexProperty
193		*
194		* @param scalar $index
195		* @return void
196		*/
197		public function unsetComplexProperty($index)
198		{
199		unset($this->complexProperty[$index]);
200		}
201
202		/**
203		* Gets as complexProperty
204		*
205		* @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType[]
206		*/
207		public function getComplexProperty()
208		{
209		return $this->complexProperty;
210		}
211
212		/**
213		* Sets a new complexProperty
214		*
215		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType[] $complexProperty
216		* @return self
217		*/
218	View Code Duplication	public function setComplexProperty(array $complexProperty)
		0 ignored issues – show Duplication introduced 2017-05-09 05:36 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...
219		{
220		$msg = null;
221		// if other arrays are empty, then the array we're assigning must not be empty
222		$count = count($this->scalarProperty) + count($this->condition);
223		if (!$this->isValidArrayOK(
224		$complexProperty,
225		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType',
226		$msg,
227		0 < $count ? 0 : 1
228		)
229		) {
230		throw new \InvalidArgumentException($msg);
231		}
232		$this->complexProperty = $complexProperty;
233		return $this;
234		}
235
236		/**
237		* Adds as condition
238		*
239		* @return self
240		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType $condition
241		*/
242	View Code Duplication	public function addToCondition(TConditionType $condition)
		0 ignored issues – show Duplication introduced 2017-05-08 12:31 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...
243		{
244		$msg = null;
245		if (!$condition->isOK($msg)) {
246		throw new \InvalidArgumentException($msg);
247		}
248		$this->condition[] = $condition;
249		return $this;
250		}
251
252		/**
253		* isset condition
254		*
255		* @param scalar $index
256		* @return boolean
257		*/
258		public function issetCondition($index)
259		{
260		return isset($this->condition[$index]);
261		}
262
263		/**
264		* unset condition
265		*
266		* @param scalar $index
267		* @return void
268		*/
269		public function unsetCondition($index)
270		{
271		unset($this->condition[$index]);
272		}
273
274		/**
275		* Gets as condition
276		*
277		* @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType[]
278		*/
279		public function getCondition()
280		{
281		return $this->condition;
282		}
283
284		/**
285		* Sets a new condition
286		*
287		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType[] $condition
288		* @return self
289		*/
290	View Code Duplication	public function setCondition(array $condition)
		0 ignored issues – show Duplication introduced 2017-05-09 05:36 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...
291		{
292		$msg = null;
293		// if other arrays are empty, then the array we're assigning must not be empty
294		$count = count($this->scalarProperty) + count($this->complexProperty);
295		if (!$this->isValidArrayOK(
296		$condition,
297		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType',
298		$msg,
299		0 < $count ? 0 : 1
300		)
301		) {
302		throw new \InvalidArgumentException($msg);
303		}
304		$this->condition = $condition;
305		return $this;
306		}
307
308		public function isOK(&$msg = null)
309		{
310	View Code Duplication	if (null != $this->typeName) {
		0 ignored issues – show Duplication introduced 2017-04-30 17:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
311		if (!$this->isStringNotNullOrEmpty($this->typeName)) {
312		$msg = 'Type name cannot be empty';
313		return false;
314		}
315		}
316		$count = count($this->scalarProperty) + count($this->complexProperty) + count($this->condition);
317		if (1 > $count) {
318		$msg = "Cannot have all arrays empty";
319		return false;
320		}
321
322		if (!$this->isValidArray(
323		$this->scalarProperty,
324		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TScalarPropertyType'
325		)
326		) {
327		$msg = "Scalar property array not a valid array";
328		return false;
329		}
330		if (!$this->isChildArrayOK($this->scalarProperty, $msg)) {
331		return false;
332		}
333		if (!$this->isValidArray(
334		$this->complexProperty,
335		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TComplexPropertyType'
336		)
337		) {
338		$msg = "Complex property array not a valid array";
339		return false;
340		}
341		if (!$this->isChildArrayOK($this->complexProperty, $msg)) {
342		return false;
343		}
344		if (!$this->isValidArray(
345		$this->condition,
346		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TConditionType'
347		)
348		) {
349		$msg = "Condition array not a valid array";
350		return false;
351		}
352		if (!$this->isChildArrayOK($this->condition, $msg)) {
353		return false;
354		}
355		return true;
356		}
357		}
358

Algo-Web / ODataMetadata