TSchemaType::getFunction() - Code Metrics - Inspection of "Move PHP namespacen to suit project" - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 583371...613693 )

by Alex

created 2017-04-27 14:24 UTC

TSchemaType::getFunction() A

↳ Parent: TSchemaType

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;

/**
 * Class representing TSchemaType
 *
 *
 * XSD Type: TSchema
 */
class TSchemaType
{

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @property \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 \MetadataV3\edm\TUsingType $using
     */
    public function addToUsing(\MetadataV3\edm\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 \MetadataV3\edm\TUsingType[]
     */
    public function getUsing()
    {
        return $this->using;
    }

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

    /**
     * Adds as association
     *
     * @return self
     * @param \MetadataV3\edm\TAssociationType $association
     */
    public function addToAssociation(\MetadataV3\edm\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 \MetadataV3\edm\TAssociationType[]
     */
    public function getAssociation()
    {
        return $this->association;
    }

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

    /**
     * Adds as complexType
     *
     * @return self
     * @param \MetadataV3\edm\TComplexTypeType $complexType
     */
    public function addToComplexType(\MetadataV3\edm\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 \MetadataV3\edm\TComplexTypeType[]
     */
    public function getComplexType()
    {
        return $this->complexType;
    }

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

    /**
     * Adds as entityType
     *
     * @return self
     * @param \MetadataV3\edm\TEntityTypeType $entityType
     */
    public function addToEntityType(\MetadataV3\edm\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 \MetadataV3\edm\TEntityTypeType[]
     */
    public function getEntityType()
    {
        return $this->entityType;
    }

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

    /**
     * Adds as enumType
     *
     * @return self
     * @param \MetadataV3\edm\TEnumTypeType $enumType
     */
    public function addToEnumType(\MetadataV3\edm\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 \MetadataV3\edm\TEnumTypeType[]
     */
    public function getEnumType()
    {
        return $this->enumType;
    }

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

    /**
     * Adds as valueTerm
     *
     * @return self
     * @param \MetadataV3\edm\TValueTermType $valueTerm
     */
    public function addToValueTerm(\MetadataV3\edm\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 \MetadataV3\edm\TValueTermType[]
     */
    public function getValueTerm()
    {
        return $this->valueTerm;
    }

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

    /**
     * Adds as function
     *
     * @return self
     * @param \MetadataV3\edm\TFunctionType $function
     */
    public function addToFunction(\MetadataV3\edm\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 \MetadataV3\edm\TFunctionType[]
     */
    public function getFunction()
    {
        return $this->function;
    }

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

    /**
     * Adds as annotations
     *
     * @return self
     * @param \MetadataV3\edm\TAnnotationsType $annotations
     */
    public function addToAnnotations(\MetadataV3\edm\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 \MetadataV3\edm\TAnnotationsType[]
     */
    public function getAnnotations()
    {
        return $this->annotations;
    }

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

    /**
     * Adds as entityContainer
     *
     * @return self
     * @param \MetadataV3\edm\EntityContainer $entityContainer
     */
    public function addToEntityContainer(\MetadataV3\edm\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 \MetadataV3\edm\EntityContainer[]
     */
    public function getEntityContainer()
    {
        return $this->entityContainer;
    }

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

Algo-Web / ODataMetadata

Push — master ( 583371...613693 )

TSchemaType::getFunction() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like