TFunctionImportAttributesTrait::isTFunctionImportAttributesValid() - Code Metrics - Inspection of "Add singleton" - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#101)

by Alex

created 2017-06-05 12:27 UTC

isTFunctionImportAttributesValid() C

↳ Parent: TFunctionImportAttributesTrait

Complexity

Conditions	8
Paths	6

Size

Total Lines	33
Code Lines	19

Duplication

Lines	4
Ratio	12.12 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	4
loc	33
rs	5.3846
cc	8
eloc	19
nc	6
nop	1

<?php

namespace AlgoWeb\ODataMetadata\MetadataV3\edm\Groups;

use AlgoWeb\ODataMetadata\CodeGeneration\AccessTypeTraits;
use AlgoWeb\ODataMetadata\IsOKTraits\IsOKToolboxTrait;
use AlgoWeb\ODataMetadata\MetadataV3\edm\IsOKTraits\TSimpleIdentifierTrait;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType;

trait TFunctionImportAttributesTrait
{
    use TSimpleIdentifierTrait, AccessTypeTraits, IsOKToolboxTrait;
    
    /**
     * @property string $name
     */
    private $name = null;

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType[] $returnType
     */
    private $returnType = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType $entitySet
     */
    private $entitySet = null;

    /**
     * @property boolean $isComposable
     */
    private $isComposable = false;

    /**
     * @property boolean $isSideEffecting
     */
    private $isSideEffecting = true;

    /**
     * @property boolean $isBindable
     */
    private $isBindable = false;

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

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

    /**
     * Sets a new name
     *
     * @param string $name
     * @return self
     */
    public function setName($name)
    {
        $msg = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if (!$this->isTSimpleIdentifierValid($name)) {
            $msg = "Name must be a valid TSimpleIdentifier";
            throw new \InvalidArgumentException($msg);
        }
        $this->name = $name;
        return $this;
    }

    /**
     * Adds as returnType
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType $returnType
     */
    public function addToReturnType(TFunctionImportReturnTypeType $returnType)

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

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

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

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

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

    /**
     * Gets as entitySet
     *
     * @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType
     */
    public function getEntitySet()
    {
        return $this->entitySet;
    }

    /**
     * Sets a new entitySet
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType $entitySet
     * @return self
     */
    public function setEntitySet(TOperandType $entitySet)

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

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

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

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

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

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

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

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

    /**
     * Sets a new methodAccess
     *
     * @param string $methodAccess
     * @return self
     */
    public function setMethodAccess($methodAccess)
    {
        $msg = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if (null != $methodAccess && $this->isTAccessOk($methodAccess)) {
            $msg = "Method access must be a valid TAccess";
            throw new \InvalidArgumentException($msg);
        }
        $this->methodAccess = $methodAccess;
        return $this;
    }
    
    
    public function isTFunctionImportAttributesValid(&$msg)
    {
        if (!$this->isTSimpleIdentifierValid($this->name)) {

            $msg = "Name must be a valid TSimpleIdentifier: " . get_class($this);
            return false;
        }
        if ($this->isComposable && $this->isSideEffecting) {
            $msg = "Cannot both be composable and side-effecting";
            return false;
        }
        /*

        if (null != $this->entitySet && !$this->isTSimpleIdentifierValid($this->entitySet)) {
            $msg = "Entity set must be a valid TSimpleIdentifier";
            return false;
        }*/
        if (!$this->isObjectNullOrType('\AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType', $this->entitySet)) {
            $msg = "Entity set must be either null or an instance of TOperandType: " . get_class($this);
            return false;
        }
        if (null != $this->methodAccess && $this->isTAccessOk($this->methodAccess)) {
            $msg = "Method access must be a valid TAccess: " . get_class($this);
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->returnType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType',
            $msg
        )) {
            return false;
        }
        
        return true;
    }
}


1		<?php
2
3		namespace AlgoWeb\ODataMetadata\MetadataV3\edm\Groups;
4
5		use AlgoWeb\ODataMetadata\CodeGeneration\AccessTypeTraits;
6		use AlgoWeb\ODataMetadata\IsOKTraits\IsOKToolboxTrait;
7		use AlgoWeb\ODataMetadata\MetadataV3\edm\IsOKTraits\TSimpleIdentifierTrait;
8		use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType;
9		use AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType;
10
11		trait TFunctionImportAttributesTrait
12		{
13		use TSimpleIdentifierTrait, AccessTypeTraits, IsOKToolboxTrait;
14
15		/**
16		* @property string $name
17		*/
18		private $name = null;
19
20		/**
21		* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType[] $returnType
22		*/
23		private $returnType = [];
24
25		/**
26		* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType $entitySet
27		*/
28		private $entitySet = null;
29
30		/**
31		* @property boolean $isComposable
32		*/
33		private $isComposable = false;
34
35		/**
36		* @property boolean $isSideEffecting
37		*/
38		private $isSideEffecting = true;
39
40		/**
41		* @property boolean $isBindable
42		*/
43		private $isBindable = false;
44
45		/**
46		* @property string $methodAccess
47		*/
48		private $methodAccess = null;
49
50		/**
51		* Gets as name
52		*
53		* @return string
54		*/
55		public function getName()
56		{
57		return $this->name;
58		}
59
60		/**
61		* Sets a new name
62		*
63		* @param string $name
64		* @return self
65		*/
66		public function setName($name)
67		{
68		$msg = null;
		0 ignored issues – show Unused Code introduced 2017-05-09 14:54 UTC by Report Bug Copy Issue Report `$msg` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
69		if (!$this->isTSimpleIdentifierValid($name)) {
70		$msg = "Name must be a valid TSimpleIdentifier";
71		throw new \InvalidArgumentException($msg);
72		}
73		$this->name = $name;
74		return $this;
75		}
76
77		/**
78		* Adds as returnType
79		*
80		* @return self
81		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType $returnType
82		*/
83	View Code Duplication	public function addToReturnType(TFunctionImportReturnTypeType $returnType)
		0 ignored issues – show Duplication introduced 2017-05-10 03:19 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...
84		{
85		$msg = null;
86		if (!$returnType->isOK($msg)) {
87		throw new \InvalidArgumentException($msg);
88		}
89		$this->returnType[] = $returnType;
90		return $this;
91		}
92
93		/**
94		* isset returnType
95		*
96		* @param scalar $index
97		* @return boolean
98		*/
99		public function issetReturnType($index)
100		{
101		return isset($this->returnType[$index]);
102		}
103
104		/**
105		* unset returnType
106		*
107		* @param scalar $index
108		* @return void
109		*/
110		public function unsetReturnType($index)
111		{
112		unset($this->returnType[$index]);
113		}
114
115		/**
116		* Gets as returnType
117		*
118		* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType[]
119		*/
120		public function getReturnType()
121		{
122		return $this->returnType;
123		}
124
125		/**
126		* Sets a new returnType
127		*
128		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType[] $returnType
129		* @return self
130		*/
131		public function setReturnType(array $returnType)
132		{
133		$msg = null;
134		if (!$this->isValidArrayOK(
135		$returnType,
136		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType',
137		$msg
138		)) {
139		throw new \InvalidArgumentException($msg);
140		}
141		$this->returnType = $returnType;
142		return $this;
143		}
144
145		/**
146		* Gets as entitySet
147		*
148		* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType
149		*/
150		public function getEntitySet()
151		{
152		return $this->entitySet;
153		}
154
155		/**
156		* Sets a new entitySet
157		*
158		* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType $entitySet
159		* @return self
160		*/
161	View Code Duplication	public function setEntitySet(TOperandType $entitySet)
		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...
162		{
163		$msg = null;
164		if (!$entitySet->isOK($msg)) {
165		throw new \InvalidArgumentException($msg);
166		}
167		$this->entitySet = $entitySet;
168		return $this;
169		}
170
171		/**
172		* Gets as isComposable
173		*
174		* @return boolean
175		*/
176		public function getIsComposable()
177		{
178		return $this->isComposable;
179		}
180
181		/**
182		* Sets a new isComposable
183		*
184		* @param boolean $isComposable
185		* @return self
186		*/
187		public function setIsComposable($isComposable)
188		{
189		$this->isComposable = boolval($isComposable);
190		return $this;
191		}
192
193		/**
194		* Gets as isSideEffecting
195		*
196		* @return boolean
197		*/
198		public function getIsSideEffecting()
199		{
200		return $this->isSideEffecting;
201		}
202
203		/**
204		* Sets a new isSideEffecting
205		*
206		* @param boolean $isSideEffecting
207		* @return self
208		*/
209		public function setIsSideEffecting($isSideEffecting)
210		{
211		$this->isSideEffecting = boolval($isSideEffecting);
212		return $this;
213		}
214
215		/**
216		* Gets as isBindable
217		*
218		* @return boolean
219		*/
220		public function getIsBindable()
221		{
222		return $this->isBindable;
223		}
224
225		/**
226		* Sets a new isBindable
227		*
228		* @param boolean $isBindable
229		* @return self
230		*/
231		public function setIsBindable($isBindable)
232		{
233		$this->isBindable = boolval($isBindable);
234		return $this;
235		}
236
237		/**
238		* Gets as methodAccess
239		*
240		* @return string
241		*/
242		public function getMethodAccess()
243		{
244		return $this->methodAccess;
245		}
246
247		/**
248		* Sets a new methodAccess
249		*
250		* @param string $methodAccess
251		* @return self
252		*/
253		public function setMethodAccess($methodAccess)
254		{
255		$msg = null;
		0 ignored issues – show Unused Code introduced 2017-05-10 03:19 UTC by Report Bug Copy Issue Report `$msg` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
256		if (null != $methodAccess && $this->isTAccessOk($methodAccess)) {
257		$msg = "Method access must be a valid TAccess";
258		throw new \InvalidArgumentException($msg);
259		}
260		$this->methodAccess = $methodAccess;
261		return $this;
262		}
263
264
265		public function isTFunctionImportAttributesValid(&$msg)
266		{
267	View Code Duplication	if (!$this->isTSimpleIdentifierValid($this->name)) {
		0 ignored issues – show Duplication introduced 2017-05-10 06:42 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...
268		$msg = "Name must be a valid TSimpleIdentifier: " . get_class($this);
269		return false;
270		}
271		if ($this->isComposable && $this->isSideEffecting) {
272		$msg = "Cannot both be composable and side-effecting";
273		return false;
274		}
275		/*
		0 ignored issues – show Unused Code Comprehensibility introduced 2017-05-03 15:45 UTC by Report Bug Copy Issue Report `57%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
276		if (null != $this->entitySet && !$this->isTSimpleIdentifierValid($this->entitySet)) {
277		$msg = "Entity set must be a valid TSimpleIdentifier";
278		return false;
279		}*/
280		if (!$this->isObjectNullOrType('\AlgoWeb\ODataMetadata\MetadataV3\edm\TOperandType', $this->entitySet)) {
281		$msg = "Entity set must be either null or an instance of TOperandType: " . get_class($this);
282		return false;
283		}
284		if (null != $this->methodAccess && $this->isTAccessOk($this->methodAccess)) {
285		$msg = "Method access must be a valid TAccess: " . get_class($this);
286		return false;
287		}
288		if (!$this->isValidArrayOK(
289		$this->returnType,
290		'\AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionImportReturnTypeType',
291		$msg
292		)) {
293		return false;
294		}
295
296		return true;
297		}
298		}
299

Algo-Web / ODataMetadata

Pull Request — master (#101)

isTFunctionImportAttributesValid() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like