TSchemaType::setComplexType() - Code Metrics - Inspection of "Added the IsOK use inheritance to V2 and V3 classe..." - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a904e5...26d68e )

by Christopher

created 2017-04-28 17:02 UTC

TSchemaType::setComplexType() A

↳ Parent: TSchemaType

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	1

<?php

namespace AlgoWeb\ODataMetadata\MetadataV3\edm;

use AlgoWeb\ODataMetadata\IsOK;

/**
 * Class representing TSchemaType
 *
 *
 * XSD Type: TSchema
 */
class TSchemaType extends IsOK

{

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * Sets a new namespace
     *
     * @param string $namespace
     * @return self
     */
    public function setNamespace($namespace)
    {
        $this->namespace = $namespace;
        return $this;
    }

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

    /**
     * Sets a new namespaceUri
     *
     * @param string $namespaceUri
     * @return self
     */
    public function setNamespaceUri($namespaceUri)
    {
        $this->namespaceUri = $namespaceUri;
        return $this;
    }

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

    /**
     * Sets a new alias
     *
     * @param string $alias
     * @return self
     */
    public function setAlias($alias)
    {
        $this->alias = $alias;
        return $this;
    }

    /**
     * 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;
    }
}


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

Algo-Web / ODataMetadata

Push — master ( a904e5...26d68e )

TSchemaType::setComplexType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like