GSchemaBodyElementsTrait::getAnnotations() - Code Metrics - Inspection of "Hook up groups for V3 edm namespace" - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( feaee9...2b3e4e )

by Alex

created 2017-05-03 15:40 UTC

GSchemaBodyElementsTrait::getAnnotations() A

↳ Parent: GSchemaBodyElementsTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

namespace AlgoWeb\ODataMetadata\MetadataV3\edm\Groups;

use AlgoWeb\ODataMetadata\IsOKTraits\IsOKToolboxTrait;
use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType;

trait GSchemaBodyElementsTrait
{
    use IsOKToolboxTrait;

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType[] $using
     */
    private $using = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType[] $association
     */
    private $association = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType[] $complexType
     */
    private $complexType = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType[] $entityType
     */
    private $entityType = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType[] $enumType
     */
    private $enumType = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType[] $valueTerm
     */
    private $valueTerm = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType[] $function
     */
    private $function = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType[] $annotations
     */
    private $annotations = [];

    /**
     * @property \AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer[] $entityContainer
     */
    private $entityContainer = [];

    /**
     * Adds as using
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType $using
     */
    public function addToUsing(TUsingType $using)
    {
        $this->using[] = $using;
        return $this;
    }

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

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

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

    /**
     * Sets a new using
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType[] $using
     * @return self
     */
    public function setUsing(array $using)
    {
        $this->using = $using;
        return $this;
    }

    /**
     * Adds as association
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType $association
     */
    public function addToAssociation(TAssociationType $association)
    {
        $this->association[] = $association;
        return $this;
    }

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

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

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

    /**
     * Sets a new association
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType[] $association
     * @return self
     */
    public function setAssociation(array $association)
    {
        $this->association = $association;
        return $this;
    }

    /**
     * Adds as complexType
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType $complexType
     */
    public function addToComplexType(TComplexTypeType $complexType)
    {
        $this->complexType[] = $complexType;
        return $this;
    }

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

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

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

    /**
     * Sets a new complexType
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType[] $complexType
     * @return self
     */
    public function setComplexType(array $complexType)
    {
        $this->complexType = $complexType;
        return $this;
    }

    /**
     * Adds as entityType
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType $entityType
     */
    public function addToEntityType(TEntityTypeType $entityType)
    {
        $this->entityType[] = $entityType;
        return $this;
    }

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

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

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

    /**
     * Sets a new entityType
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType[] $entityType
     * @return self
     */
    public function setEntityType(array $entityType)
    {
        $this->entityType = $entityType;
        return $this;
    }

    /**
     * Adds as enumType
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType $enumType
     */
    public function addToEnumType(TEnumTypeType $enumType)
    {
        $this->enumType[] = $enumType;
        return $this;
    }

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

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

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

    /**
     * Sets a new enumType
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType[] $enumType
     * @return self
     */
    public function setEnumType(array $enumType)
    {
        $this->enumType = $enumType;
        return $this;
    }

    /**
     * Adds as valueTerm
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType $valueTerm
     */
    public function addToValueTerm(TValueTermType $valueTerm)
    {
        $this->valueTerm[] = $valueTerm;
        return $this;
    }

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

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

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

    /**
     * Sets a new valueTerm
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType[] $valueTerm
     * @return self
     */
    public function setValueTerm(array $valueTerm)
    {
        $this->valueTerm = $valueTerm;
        return $this;
    }

    /**
     * Adds as function
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType $function
     */
    public function addToFunction(TFunctionType $function)
    {
        $this->function[] = $function;
        return $this;
    }

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

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

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

    /**
     * Sets a new function
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType[] $function
     * @return self
     */
    public function setFunction(array $function)
    {
        $this->function = $function;
        return $this;
    }

    /**
     * Adds as annotations
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType $annotations
     */
    public function addToAnnotations(TAnnotationsType $annotations)
    {
        $this->annotations[] = $annotations;
        return $this;
    }

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

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

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

    /**
     * Sets a new annotations
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType[] $annotations
     * @return self
     */
    public function setAnnotations(array $annotations)
    {
        $this->annotations = $annotations;
        return $this;
    }

    /**
     * Adds as entityContainer
     *
     * @return self
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer $entityContainer
     */
    public function addToEntityContainer(EntityContainer $entityContainer)
    {
        $this->entityContainer[] = $entityContainer;
        return $this;
    }

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

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

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

    /**
     * Sets a new entityContainer
     *
     * @param \AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer[] $entityContainer
     * @return self
     */
    public function setEntityContainer(array $entityContainer)
    {
        $this->entityContainer = $entityContainer;
        return $this;
    }


    public function isGSchemaBodyElementsValid(&$msg = null)
    {
        if (!$this->isValidArrayOK($this->using, '\AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType', $msg)) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->association,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->complexType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->entityType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->enumType,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->valueTerm,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->function,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->annotations,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType',
            $msg
        )) {
            return false;
        }
        if (!$this->isValidArrayOK(
            $this->entityContainer,
            '\AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer',
            $msg
        )) {
            return false;
        }

        return true;
    }
}


1			<?php
2
3			namespace AlgoWeb\ODataMetadata\MetadataV3\edm\Groups;
4
5			use AlgoWeb\ODataMetadata\IsOKTraits\IsOKToolboxTrait;
6			use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer;
7			use AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType;
8			use AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType;
9			use AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType;
10			use AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType;
11			use AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType;
12			use AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType;
13			use AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType;
14			use AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType;
15
16			trait GSchemaBodyElementsTrait
17			{
18			use IsOKToolboxTrait;
19
20			/**
21			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType[] $using
22			*/
23			private $using = [];
24
25			/**
26			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType[] $association
27			*/
28			private $association = [];
29
30			/**
31			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType[] $complexType
32			*/
33			private $complexType = [];
34
35			/**
36			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType[] $entityType
37			*/
38			private $entityType = [];
39
40			/**
41			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType[] $enumType
42			*/
43			private $enumType = [];
44
45			/**
46			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType[] $valueTerm
47			*/
48			private $valueTerm = [];
49
50			/**
51			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType[] $function
52			*/
53			private $function = [];
54
55			/**
56			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType[] $annotations
57			*/
58			private $annotations = [];
59
60			/**
61			* @property \AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer[] $entityContainer
62			*/
63			private $entityContainer = [];
64
65			/**
66			* Adds as using
67			*
68			* @return self
69			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType $using
70			*/
71			public function addToUsing(TUsingType $using)
72			{
73			$this->using[] = $using;
74			return $this;
75			}
76
77			/**
78			* isset using
79			*
80			* @param scalar $index
81			* @return boolean
82			*/
83			public function issetUsing($index)
84			{
85			return isset($this->using[$index]);
86			}
87
88			/**
89			* unset using
90			*
91			* @param scalar $index
92			* @return void
93			*/
94			public function unsetUsing($index)
95			{
96			unset($this->using[$index]);
97			}
98
99			/**
100			* Gets as using
101			*
102			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType[]
103			*/
104			public function getUsing()
105			{
106			return $this->using;
107			}
108
109			/**
110			* Sets a new using
111			*
112			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType[] $using
113			* @return self
114			*/
115			public function setUsing(array $using)
116			{
117			$this->using = $using;
118			return $this;
119			}
120
121			/**
122			* Adds as association
123			*
124			* @return self
125			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType $association
126			*/
127			public function addToAssociation(TAssociationType $association)
128			{
129			$this->association[] = $association;
130			return $this;
131			}
132
133			/**
134			* isset association
135			*
136			* @param scalar $index
137			* @return boolean
138			*/
139			public function issetAssociation($index)
140			{
141			return isset($this->association[$index]);
142			}
143
144			/**
145			* unset association
146			*
147			* @param scalar $index
148			* @return void
149			*/
150			public function unsetAssociation($index)
151			{
152			unset($this->association[$index]);
153			}
154
155			/**
156			* Gets as association
157			*
158			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType[]
159			*/
160			public function getAssociation()
161			{
162			return $this->association;
163			}
164
165			/**
166			* Sets a new association
167			*
168			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType[] $association
169			* @return self
170			*/
171			public function setAssociation(array $association)
172			{
173			$this->association = $association;
174			return $this;
175			}
176
177			/**
178			* Adds as complexType
179			*
180			* @return self
181			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType $complexType
182			*/
183			public function addToComplexType(TComplexTypeType $complexType)
184			{
185			$this->complexType[] = $complexType;
186			return $this;
187			}
188
189			/**
190			* isset complexType
191			*
192			* @param scalar $index
193			* @return boolean
194			*/
195			public function issetComplexType($index)
196			{
197			return isset($this->complexType[$index]);
198			}
199
200			/**
201			* unset complexType
202			*
203			* @param scalar $index
204			* @return void
205			*/
206			public function unsetComplexType($index)
207			{
208			unset($this->complexType[$index]);
209			}
210
211			/**
212			* Gets as complexType
213			*
214			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType[]
215			*/
216			public function getComplexType()
217			{
218			return $this->complexType;
219			}
220
221			/**
222			* Sets a new complexType
223			*
224			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType[] $complexType
225			* @return self
226			*/
227			public function setComplexType(array $complexType)
228			{
229			$this->complexType = $complexType;
230			return $this;
231			}
232
233			/**
234			* Adds as entityType
235			*
236			* @return self
237			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType $entityType
238			*/
239			public function addToEntityType(TEntityTypeType $entityType)
240			{
241			$this->entityType[] = $entityType;
242			return $this;
243			}
244
245			/**
246			* isset entityType
247			*
248			* @param scalar $index
249			* @return boolean
250			*/
251			public function issetEntityType($index)
252			{
253			return isset($this->entityType[$index]);
254			}
255
256			/**
257			* unset entityType
258			*
259			* @param scalar $index
260			* @return void
261			*/
262			public function unsetEntityType($index)
263			{
264			unset($this->entityType[$index]);
265			}
266
267			/**
268			* Gets as entityType
269			*
270			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType[]
271			*/
272			public function getEntityType()
273			{
274			return $this->entityType;
275			}
276
277			/**
278			* Sets a new entityType
279			*
280			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType[] $entityType
281			* @return self
282			*/
283			public function setEntityType(array $entityType)
284			{
285			$this->entityType = $entityType;
286			return $this;
287			}
288
289			/**
290			* Adds as enumType
291			*
292			* @return self
293			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType $enumType
294			*/
295			public function addToEnumType(TEnumTypeType $enumType)
296			{
297			$this->enumType[] = $enumType;
298			return $this;
299			}
300
301			/**
302			* isset enumType
303			*
304			* @param scalar $index
305			* @return boolean
306			*/
307			public function issetEnumType($index)
308			{
309			return isset($this->enumType[$index]);
310			}
311
312			/**
313			* unset enumType
314			*
315			* @param scalar $index
316			* @return void
317			*/
318			public function unsetEnumType($index)
319			{
320			unset($this->enumType[$index]);
321			}
322
323			/**
324			* Gets as enumType
325			*
326			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType[]
327			*/
328			public function getEnumType()
329			{
330			return $this->enumType;
331			}
332
333			/**
334			* Sets a new enumType
335			*
336			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType[] $enumType
337			* @return self
338			*/
339			public function setEnumType(array $enumType)
340			{
341			$this->enumType = $enumType;
342			return $this;
343			}
344
345			/**
346			* Adds as valueTerm
347			*
348			* @return self
349			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType $valueTerm
350			*/
351			public function addToValueTerm(TValueTermType $valueTerm)
352			{
353			$this->valueTerm[] = $valueTerm;
354			return $this;
355			}
356
357			/**
358			* isset valueTerm
359			*
360			* @param scalar $index
361			* @return boolean
362			*/
363			public function issetValueTerm($index)
364			{
365			return isset($this->valueTerm[$index]);
366			}
367
368			/**
369			* unset valueTerm
370			*
371			* @param scalar $index
372			* @return void
373			*/
374			public function unsetValueTerm($index)
375			{
376			unset($this->valueTerm[$index]);
377			}
378
379			/**
380			* Gets as valueTerm
381			*
382			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType[]
383			*/
384			public function getValueTerm()
385			{
386			return $this->valueTerm;
387			}
388
389			/**
390			* Sets a new valueTerm
391			*
392			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType[] $valueTerm
393			* @return self
394			*/
395			public function setValueTerm(array $valueTerm)
396			{
397			$this->valueTerm = $valueTerm;
398			return $this;
399			}
400
401			/**
402			* Adds as function
403			*
404			* @return self
405			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType $function
406			*/
407			public function addToFunction(TFunctionType $function)
408			{
409			$this->function[] = $function;
410			return $this;
411			}
412
413			/**
414			* isset function
415			*
416			* @param scalar $index
417			* @return boolean
418			*/
419			public function issetFunction($index)
420			{
421			return isset($this->function[$index]);
422			}
423
424			/**
425			* unset function
426			*
427			* @param scalar $index
428			* @return void
429			*/
430			public function unsetFunction($index)
431			{
432			unset($this->function[$index]);
433			}
434
435			/**
436			* Gets as function
437			*
438			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType[]
439			*/
440			public function getFunction()
441			{
442			return $this->function;
443			}
444
445			/**
446			* Sets a new function
447			*
448			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType[] $function
449			* @return self
450			*/
451			public function setFunction(array $function)
452			{
453			$this->function = $function;
454			return $this;
455			}
456
457			/**
458			* Adds as annotations
459			*
460			* @return self
461			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType $annotations
462			*/
463			public function addToAnnotations(TAnnotationsType $annotations)
464			{
465			$this->annotations[] = $annotations;
466			return $this;
467			}
468
469			/**
470			* isset annotations
471			*
472			* @param scalar $index
473			* @return boolean
474			*/
475			public function issetAnnotations($index)
476			{
477			return isset($this->annotations[$index]);
478			}
479
480			/**
481			* unset annotations
482			*
483			* @param scalar $index
484			* @return void
485			*/
486			public function unsetAnnotations($index)
487			{
488			unset($this->annotations[$index]);
489			}
490
491			/**
492			* Gets as annotations
493			*
494			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType[]
495			*/
496			public function getAnnotations()
497			{
498			return $this->annotations;
499			}
500
501			/**
502			* Sets a new annotations
503			*
504			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType[] $annotations
505			* @return self
506			*/
507			public function setAnnotations(array $annotations)
508			{
509			$this->annotations = $annotations;
510			return $this;
511			}
512
513			/**
514			* Adds as entityContainer
515			*
516			* @return self
517			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer $entityContainer
518			*/
519			public function addToEntityContainer(EntityContainer $entityContainer)
520			{
521			$this->entityContainer[] = $entityContainer;
522			return $this;
523			}
524
525			/**
526			* isset entityContainer
527			*
528			* @param scalar $index
529			* @return boolean
530			*/
531			public function issetEntityContainer($index)
532			{
533			return isset($this->entityContainer[$index]);
534			}
535
536			/**
537			* unset entityContainer
538			*
539			* @param scalar $index
540			* @return void
541			*/
542			public function unsetEntityContainer($index)
543			{
544			unset($this->entityContainer[$index]);
545			}
546
547			/**
548			* Gets as entityContainer
549			*
550			* @return \AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer[]
551			*/
552			public function getEntityContainer()
553			{
554			return $this->entityContainer;
555			}
556
557			/**
558			* Sets a new entityContainer
559			*
560			* @param \AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer[] $entityContainer
561			* @return self
562			*/
563			public function setEntityContainer(array $entityContainer)
564			{
565			$this->entityContainer = $entityContainer;
566			return $this;
567			}
568
569
570			public function isGSchemaBodyElementsValid(&$msg = null)
571			{
572			if (!$this->isValidArrayOK($this->using, '\AlgoWeb\ODataMetadata\MetadataV3\edm\TUsingType', $msg)) {
573			return false;
574			}
575			if (!$this->isValidArrayOK(
576			$this->association,
577			'\AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType',
578			$msg
579			)) {
580			return false;
581			}
582			if (!$this->isValidArrayOK(
583			$this->complexType,
584			'\AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType',
585			$msg
586			)) {
587			return false;
588			}
589			if (!$this->isValidArrayOK(
590			$this->entityType,
591			'\AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType',
592			$msg
593			)) {
594			return false;
595			}
596			if (!$this->isValidArrayOK(
597			$this->enumType,
598			'\AlgoWeb\ODataMetadata\MetadataV3\edm\TEnumTypeType',
599			$msg
600			)) {
601			return false;
602			}
603			if (!$this->isValidArrayOK(
604			$this->valueTerm,
605			'\AlgoWeb\ODataMetadata\MetadataV3\edm\TValueTermType',
606			$msg
607			)) {
608			return false;
609			}
610			if (!$this->isValidArrayOK(
611			$this->function,
612			'\AlgoWeb\ODataMetadata\MetadataV3\edm\TFunctionType',
613			$msg
614			)) {
615			return false;
616			}
617			if (!$this->isValidArrayOK(
618			$this->annotations,
619			'\AlgoWeb\ODataMetadata\MetadataV3\edm\TAnnotationsType',
620			$msg
621			)) {
622			return false;
623			}
624			if (!$this->isValidArrayOK(
625			$this->entityContainer,
626			'\AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer',
627			$msg
628			)) {
629			return false;
630			}
631
632			return true;
633			}
634			}
635

Algo-Web / ODataMetadata

Push — master ( feaee9...2b3e4e )

GSchemaBodyElementsTrait::getAnnotations() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like