TEntityContainerMappingType - 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

TEntityContainerMappingType B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	372
Duplicated Lines	17.74 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
wmc	40
lcom	1
cbo	5
dl	66
loc	372
rs	8.2608
c	0
b	0
f	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	getCdmEntityContainer()	0	4	1
A	setCdmEntityContainer()	0	13	3
A	getStorageEntityContainer()	0	4	1
A	setStorageEntityContainer()	0	9	2
A	getGenerateUpdateViews()	0	4	1
A	setGenerateUpdateViews()	0	5	1
A	addToEntitySetMapping()	9	9	2
A	issetEntitySetMapping()	0	4	1
A	unsetEntitySetMapping()	0	4	1
A	getEntitySetMapping()	0	4	1
A	setEntitySetMapping()	13	14	2
A	addToAssociationSetMapping()	9	9	2
A	issetAssociationSetMapping()	0	4	1
A	unsetAssociationSetMapping()	0	4	1
A	getAssociationSetMapping()	0	4	1
A	setAssociationSetMapping()	13	14	2
A	addToFunctionImportMapping()	9	9	2
A	issetFunctionImportMapping()	0	4	1
A	unsetFunctionImportMapping()	0	4	1
A	getFunctionImportMapping()	0	4	1
A	setFunctionImportMapping()	13	14	2
C	isOK()	0	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 TEntityContainerMappingType 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 TEntityContainerMappingType, and based on these observations, apply Extract Interface, too.

<?php

namespace AlgoWeb\ODataMetadata\MetadataV3\mapping\cs;

use AlgoWeb\ODataMetadata\IsOK;
use AlgoWeb\ODataMetadata\MetadataV4\edm\IsOKTraits\TSimpleIdentifierTrait;

/**
 * Class representing TEntityContainerMappingType
 *
 * Type for EntityContainerMapping element
 *
 * XSD Type: TEntityContainerMapping
 */
class TEntityContainerMappingType extends IsOK
{
    use TSimpleIdentifierTrait;
    /**
     * @property string $cdmEntityContainer
     */
    private $cdmEntityContainer = null;

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

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

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

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

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

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

    /**
     * Sets a new cdmEntityContainer
     *
     * @param  string $cdmEntityContainer
     * @return self
     */
    public function setCdmEntityContainer($cdmEntityContainer)
    {
        if (!$this->isStringNotNullOrEmpty($cdmEntityContainer)) {
            $msg = 'CDM entity container cannot be null or empty';
            throw new \InvalidArgumentException($msg);
        }
        if (!$this->isTSimpleIdentifierValid($cdmEntityContainer)) {
            $msg = 'CDM entity container must be a valid TSimpleIdentifier';
            throw new \InvalidArgumentException($msg);
        }
        $this->cdmEntityContainer = $cdmEntityContainer;
        return $this;
    }

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

    /**
     * Sets a new storageEntityContainer
     *
     * @param  string $storageEntityContainer
     * @return self
     */
    public function setStorageEntityContainer($storageEntityContainer)
    {
        if (!$this->isStringNotNullOrEmpty($storageEntityContainer)) {
            $msg = 'Storage entity container cannot be null or empty';
            throw new \InvalidArgumentException($msg);
        }
        $this->storageEntityContainer = $storageEntityContainer;
        return $this;
    }

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

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

    /**
     * Adds as entitySetMapping
     *
     * @return self
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType $entitySetMapping
     */
    public function addToEntitySetMapping(TEntitySetMappingType $entitySetMapping)

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

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

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

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

    /**
     * Sets a new entitySetMapping
     *
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType[] $entitySetMapping
     * @return self
     */
    public function setEntitySetMapping(array $entitySetMapping)

    {
        $msg = null;
        if (!$this->isValidArrayOK(
            $entitySetMapping,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType',
            $msg
        )
        ) {
            throw new \InvalidArgumentException($msg);
        }
        $this->entitySetMapping = $entitySetMapping;
        return $this;
    }

    /**
     * Adds as associationSetMapping
     *
     * @return self
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType $associationSetMapping
     */
    public function addToAssociationSetMapping(TAssociationSetMappingType $associationSetMapping)

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

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

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

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

    /**
     * Sets a new associationSetMapping
     *
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType[]
     * $associationSetMapping
     * @return self
     */
    public function setAssociationSetMapping(array $associationSetMapping)

    {
        $msg = null;
        if (!$this->isValidArrayOK(
            $associationSetMapping,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType',
            $msg
        )
        ) {
            throw new \InvalidArgumentException($msg);
        }
        $this->associationSetMapping = $associationSetMapping;
        return $this;
    }

    /**
     * Adds as functionImportMapping
     *
     * @return self
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType $functionImportMapping
     */
    public function addToFunctionImportMapping(TFunctionImportMappingType $functionImportMapping)

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

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

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

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

    /**
     * Sets a new functionImportMapping
     *
     * @param  \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType[]
     * $functionImportMapping
     * @return self
     */
    public function setFunctionImportMapping(array $functionImportMapping)

    {
        $msg = null;
        if (!$this->isValidArrayOK(
            $functionImportMapping,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType',
            $msg
        )
        ) {
            throw new \InvalidArgumentException($msg);
        }
        $this->functionImportMapping = $functionImportMapping;
        return $this;
    }

    public function isOK(&$msg = null)
    {
        if (!$this->isStringNotNullOrEmpty($this->cdmEntityContainer)) {
            $msg = 'CDM entity container cannot be null or empty';
            return false;
        }
        if (!$this->isStringNotNullOrEmpty($this->storageEntityContainer)) {
            $msg = 'Storage entity container cannot be null or empty';
            return false;
        }
        if (!$this->isTSimpleIdentifierValid($this->cdmEntityContainer)) {
            $msg = 'CDM entity container must be a valid TSimpleIdentifier';
            return false;
        }
        if (!$this->isValidArray(
            $this->entitySetMapping,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType'
        )
        ) {
            $msg = "Entity set mapping array not a valid array";
            return false;
        }
        if (!$this->isChildArrayOK($this->entitySetMapping, $msg)) {
            return false;
        }
        if (!$this->isValidArray(
            $this->associationSetMapping,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType'
        )
        ) {
            $msg = "Association set mapping array not a valid array";
            return false;
        }
        if (!$this->isChildArrayOK($this->associationSetMapping, $msg)) {
            return false;
        }
        if (!$this->isValidArray(
            $this->functionImportMapping,
            '\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType'
        )
        ) {
            $msg = "Function import mapping array not a valid array";
            return false;
        }
        if (!$this->isChildArrayOK($this->functionImportMapping, $msg)) {
            return false;
        }
        return true;
    }
}


1		<?php
2
3		namespace AlgoWeb\ODataMetadata\MetadataV3\mapping\cs;
4
5		use AlgoWeb\ODataMetadata\IsOK;
6		use AlgoWeb\ODataMetadata\MetadataV4\edm\IsOKTraits\TSimpleIdentifierTrait;
7
8		/**
9		* Class representing TEntityContainerMappingType
10		*
11		* Type for EntityContainerMapping element
12		*
13		* XSD Type: TEntityContainerMapping
14		*/
15		class TEntityContainerMappingType extends IsOK
16		{
17		use TSimpleIdentifierTrait;
18		/**
19		* @property string $cdmEntityContainer
20		*/
21		private $cdmEntityContainer = null;
22
23		/**
24		* @property string $storageEntityContainer
25		*/
26		private $storageEntityContainer = null;
27
28		/**
29		* @property boolean $generateUpdateViews
30		*/
31		private $generateUpdateViews = null;
32
33		/**
34		* @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType[] $entitySetMapping
35		*/
36		private $entitySetMapping = [];
37
38		/**
39		* @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType[]
40		* $associationSetMapping
41		*/
42		private $associationSetMapping = [];
43
44		/**
45		* @property \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType[]
46		* $functionImportMapping
47		*/
48		private $functionImportMapping = [];
49
50		/**
51		* Gets as cdmEntityContainer
52		*
53		* @return string
54		*/
55		public function getCdmEntityContainer()
56		{
57		return $this->cdmEntityContainer;
58		}
59
60		/**
61		* Sets a new cdmEntityContainer
62		*
63		* @param string $cdmEntityContainer
64		* @return self
65		*/
66		public function setCdmEntityContainer($cdmEntityContainer)
67		{
68		if (!$this->isStringNotNullOrEmpty($cdmEntityContainer)) {
69		$msg = 'CDM entity container cannot be null or empty';
70		throw new \InvalidArgumentException($msg);
71		}
72		if (!$this->isTSimpleIdentifierValid($cdmEntityContainer)) {
73		$msg = 'CDM entity container must be a valid TSimpleIdentifier';
74		throw new \InvalidArgumentException($msg);
75		}
76		$this->cdmEntityContainer = $cdmEntityContainer;
77		return $this;
78		}
79
80		/**
81		* Gets as storageEntityContainer
82		*
83		* @return string
84		*/
85		public function getStorageEntityContainer()
86		{
87		return $this->storageEntityContainer;
88		}
89
90		/**
91		* Sets a new storageEntityContainer
92		*
93		* @param string $storageEntityContainer
94		* @return self
95		*/
96		public function setStorageEntityContainer($storageEntityContainer)
97		{
98		if (!$this->isStringNotNullOrEmpty($storageEntityContainer)) {
99		$msg = 'Storage entity container cannot be null or empty';
100		throw new \InvalidArgumentException($msg);
101		}
102		$this->storageEntityContainer = $storageEntityContainer;
103		return $this;
104		}
105
106		/**
107		* Gets as generateUpdateViews
108		*
109		* @return boolean
110		*/
111		public function getGenerateUpdateViews()
112		{
113		return $this->generateUpdateViews;
114		}
115
116		/**
117		* Sets a new generateUpdateViews
118		*
119		* @param boolean $generateUpdateViews
120		* @return self
121		*/
122		public function setGenerateUpdateViews($generateUpdateViews)
123		{
124		$this->generateUpdateViews = $generateUpdateViews;
125		return $this;
126		}
127
128		/**
129		* Adds as entitySetMapping
130		*
131		* @return self
132		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType $entitySetMapping
133		*/
134	View Code Duplication	public function addToEntitySetMapping(TEntitySetMappingType $entitySetMapping)
		0 ignored issues – show Duplication introduced 2017-05-08 13:08 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...
135		{
136		$msg = null;
137		if (!$entitySetMapping->isOK($msg)) {
138		throw new \InvalidArgumentException($msg);
139		}
140		$this->entitySetMapping[] = $entitySetMapping;
141		return $this;
142		}
143
144		/**
145		* isset entitySetMapping
146		*
147		* @param scalar $index
148		* @return boolean
149		*/
150		public function issetEntitySetMapping($index)
151		{
152		return isset($this->entitySetMapping[$index]);
153		}
154
155		/**
156		* unset entitySetMapping
157		*
158		* @param scalar $index
159		* @return void
160		*/
161		public function unsetEntitySetMapping($index)
162		{
163		unset($this->entitySetMapping[$index]);
164		}
165
166		/**
167		* Gets as entitySetMapping
168		*
169		* @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType[]
170		*/
171		public function getEntitySetMapping()
172		{
173		return $this->entitySetMapping;
174		}
175
176		/**
177		* Sets a new entitySetMapping
178		*
179		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType[] $entitySetMapping
180		* @return self
181		*/
182	View Code Duplication	public function setEntitySetMapping(array $entitySetMapping)
		0 ignored issues – show Duplication introduced 2017-05-08 13:08 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...
183		{
184		$msg = null;
185		if (!$this->isValidArrayOK(
186		$entitySetMapping,
187		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType',
188		$msg
189		)
190		) {
191		throw new \InvalidArgumentException($msg);
192		}
193		$this->entitySetMapping = $entitySetMapping;
194		return $this;
195		}
196
197		/**
198		* Adds as associationSetMapping
199		*
200		* @return self
201		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType $associationSetMapping
202		*/
203	View Code Duplication	public function addToAssociationSetMapping(TAssociationSetMappingType $associationSetMapping)
		0 ignored issues – show Duplication introduced 2017-05-08 13:08 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...
204		{
205		$msg = null;
206		if (!$associationSetMapping->isOK($msg)) {
207		throw new \InvalidArgumentException($msg);
208		}
209		$this->associationSetMapping[] = $associationSetMapping;
210		return $this;
211		}
212
213		/**
214		* isset associationSetMapping
215		*
216		* @param scalar $index
217		* @return boolean
218		*/
219		public function issetAssociationSetMapping($index)
220		{
221		return isset($this->associationSetMapping[$index]);
222		}
223
224		/**
225		* unset associationSetMapping
226		*
227		* @param scalar $index
228		* @return void
229		*/
230		public function unsetAssociationSetMapping($index)
231		{
232		unset($this->associationSetMapping[$index]);
233		}
234
235		/**
236		* Gets as associationSetMapping
237		*
238		* @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType[]
239		*/
240		public function getAssociationSetMapping()
241		{
242		return $this->associationSetMapping;
243		}
244
245		/**
246		* Sets a new associationSetMapping
247		*
248		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType[]
249		* $associationSetMapping
250		* @return self
251		*/
252	View Code Duplication	public function setAssociationSetMapping(array $associationSetMapping)
		0 ignored issues – show Duplication introduced 2017-05-08 13:08 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...
253		{
254		$msg = null;
255		if (!$this->isValidArrayOK(
256		$associationSetMapping,
257		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType',
258		$msg
259		)
260		) {
261		throw new \InvalidArgumentException($msg);
262		}
263		$this->associationSetMapping = $associationSetMapping;
264		return $this;
265		}
266
267		/**
268		* Adds as functionImportMapping
269		*
270		* @return self
271		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType $functionImportMapping
272		*/
273	View Code Duplication	public function addToFunctionImportMapping(TFunctionImportMappingType $functionImportMapping)
		0 ignored issues – show Duplication introduced 2017-05-08 13:08 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...
274		{
275		$msg = null;
276		if (!$functionImportMapping->isOK($msg)) {
277		throw new \InvalidArgumentException($msg);
278		}
279		$this->functionImportMapping[] = $functionImportMapping;
280		return $this;
281		}
282
283		/**
284		* isset functionImportMapping
285		*
286		* @param scalar $index
287		* @return boolean
288		*/
289		public function issetFunctionImportMapping($index)
290		{
291		return isset($this->functionImportMapping[$index]);
292		}
293
294		/**
295		* unset functionImportMapping
296		*
297		* @param scalar $index
298		* @return void
299		*/
300		public function unsetFunctionImportMapping($index)
301		{
302		unset($this->functionImportMapping[$index]);
303		}
304
305		/**
306		* Gets as functionImportMapping
307		*
308		* @return \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType[]
309		*/
310		public function getFunctionImportMapping()
311		{
312		return $this->functionImportMapping;
313		}
314
315		/**
316		* Sets a new functionImportMapping
317		*
318		* @param \AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType[]
319		* $functionImportMapping
320		* @return self
321		*/
322	View Code Duplication	public function setFunctionImportMapping(array $functionImportMapping)
		0 ignored issues – show Duplication introduced 2017-05-08 13:08 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...
323		{
324		$msg = null;
325		if (!$this->isValidArrayOK(
326		$functionImportMapping,
327		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType',
328		$msg
329		)
330		) {
331		throw new \InvalidArgumentException($msg);
332		}
333		$this->functionImportMapping = $functionImportMapping;
334		return $this;
335		}
336
337		public function isOK(&$msg = null)
338		{
339		if (!$this->isStringNotNullOrEmpty($this->cdmEntityContainer)) {
340		$msg = 'CDM entity container cannot be null or empty';
341		return false;
342		}
343		if (!$this->isStringNotNullOrEmpty($this->storageEntityContainer)) {
344		$msg = 'Storage entity container cannot be null or empty';
345		return false;
346		}
347		if (!$this->isTSimpleIdentifierValid($this->cdmEntityContainer)) {
348		$msg = 'CDM entity container must be a valid TSimpleIdentifier';
349		return false;
350		}
351		if (!$this->isValidArray(
352		$this->entitySetMapping,
353		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TEntitySetMappingType'
354		)
355		) {
356		$msg = "Entity set mapping array not a valid array";
357		return false;
358		}
359		if (!$this->isChildArrayOK($this->entitySetMapping, $msg)) {
360		return false;
361		}
362		if (!$this->isValidArray(
363		$this->associationSetMapping,
364		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TAssociationSetMappingType'
365		)
366		) {
367		$msg = "Association set mapping array not a valid array";
368		return false;
369		}
370		if (!$this->isChildArrayOK($this->associationSetMapping, $msg)) {
371		return false;
372		}
373		if (!$this->isValidArray(
374		$this->functionImportMapping,
375		'\AlgoWeb\ODataMetadata\MetadataV3\mapping\cs\TFunctionImportMappingType'
376		)
377		) {
378		$msg = "Function import mapping array not a valid array";
379		return false;
380		}
381		if (!$this->isChildArrayOK($this->functionImportMapping, $msg)) {
382		return false;
383		}
384		return true;
385		}
386		}
387

Algo-Web / ODataMetadata