TOneChildExpressionType::addToAnnotation() - 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

TOneChildExpressionType::addToAnnotation() A

↳ Parent: TOneChildExpressionType

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\MetadataV4\edm;

/**
 * Class representing TOneChildExpressionType
 *
 *
 * XSD Type: TOneChildExpression
 */
class TOneChildExpressionType
{

    /**
     * @property \MetadataV4\edm\Annotation[] $annotation
     */
    private $annotation = array(
        
    );

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

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

    /**
     * @property \DateTime $date
     */
    private $date = null;

    /**
     * @property \DateTime $dateTimeOffset
     */
    private $dateTimeOffset = null;

    /**
     * @property float $decimal
     */
    private $decimal = null;

    /**
     * @property \DateInterval $duration
     */
    private $duration = null;

    /**
     * @property string[] $enumMember
     */
    private $enumMember = null;

    /**
     * @property float $float
     */
    private $float = null;

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

    /**
     * @property integer $int
     */
    private $int = null;

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

    /**
     * @property \DateTime $timeOfDay
     */
    private $timeOfDay = null;

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

    /**
     * @property \MetadataV4\edm\TApplyExpressionType $apply
     */
    private $apply = null;

    /**
     * @property \MetadataV4\edm\TCastOrIsOfExpressionType $cast
     */
    private $cast = null;

    /**
     * @property \MetadataV4\edm\TCollectionExpressionType $collection
     */
    private $collection = null;

    /**
     * @property \MetadataV4\edm\TIfExpressionType $if
     */
    private $if = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $eq
     */
    private $eq = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $ne
     */
    private $ne = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $ge
     */
    private $ge = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $gt
     */
    private $gt = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $le
     */
    private $le = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $lt
     */
    private $lt = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $and
     */
    private $and = null;

    /**
     * @property \MetadataV4\edm\TTwoChildrenExpressionType $or
     */
    private $or = null;

    /**
     * @property \MetadataV4\edm\TOneChildExpressionType $not
     */
    private $not = null;

    /**
     * @property \MetadataV4\edm\TCastOrIsOfExpressionType $isOf
     */
    private $isOf = null;

    /**
     * @property \MetadataV4\edm\TLabeledElementExpressionType $labeledElement
     */
    private $labeledElement = null;

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

    /**
     * @property \MetadataV4\edm\Annotation[] $null
     */
    private $null = null;

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

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

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

    /**
     * @property \MetadataV4\edm\TRecordExpressionType $record
     */
    private $record = null;

    /**
     * @property \MetadataV4\edm\TOneChildExpressionType $urlRef
     */
    private $urlRef = null;

    /**
     * Adds as annotation
     *
     * @return self
     * @param \MetadataV4\edm\Annotation $annotation
     */
    public function addToAnnotation(\MetadataV4\edm\Annotation $annotation)
    {
        $this->annotation[] = $annotation;
        return $this;
    }

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

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

    /**
     * Gets as annotation
     *
     * @return \MetadataV4\edm\Annotation[]
     */
    public function getAnnotation()
    {
        return $this->annotation;
    }

    /**
     * Sets a new annotation
     *
     * @param \MetadataV4\edm\Annotation[] $annotation
     * @return self
     */
    public function setAnnotation(array $annotation)
    {
        $this->annotation = $annotation;
        return $this;
    }

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

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

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

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

    /**
     * Gets as date
     *
     * @return \DateTime
     */
    public function getDate()
    {
        return $this->date;
    }

    /**
     * Sets a new date
     *
     * @param \DateTime $date
     * @return self
     */
    public function setDate(\DateTime $date)
    {
        $this->date = $date;
        return $this;
    }

    /**
     * Gets as dateTimeOffset
     *
     * @return \DateTime
     */
    public function getDateTimeOffset()
    {
        return $this->dateTimeOffset;
    }

    /**
     * Sets a new dateTimeOffset
     *
     * @param \DateTime $dateTimeOffset
     * @return self
     */
    public function setDateTimeOffset(\DateTime $dateTimeOffset)
    {
        $this->dateTimeOffset = $dateTimeOffset;
        return $this;
    }

    /**
     * Gets as decimal
     *
     * @return float
     */
    public function getDecimal()
    {
        return $this->decimal;
    }

    /**
     * Sets a new decimal
     *
     * @param float $decimal
     * @return self
     */
    public function setDecimal($decimal)
    {
        $this->decimal = $decimal;
        return $this;
    }

    /**
     * Gets as duration
     *
     * @return \DateInterval
     */
    public function getDuration()
    {
        return $this->duration;
    }

    /**
     * Sets a new duration
     *
     * @param \DateInterval $duration
     * @return self
     */
    public function setDuration(\DateInterval $duration)
    {
        $this->duration = $duration;
        return $this;
    }

    /**
     * Adds as enumMember
     *
     * @return self
     * @param string $enumMember
     */
    public function addToEnumMember($enumMember)
    {
        $this->enumMember[] = $enumMember;
        return $this;
    }

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

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

    /**
     * Gets as enumMember
     *
     * @return string[]
     */
    public function getEnumMember()
    {
        return $this->enumMember;
    }

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

    /**
     * Gets as float
     *
     * @return float
     */
    public function getFloat()
    {
        return $this->float;
    }

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

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

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

    /**
     * Gets as int
     *
     * @return integer
     */
    public function getInt()
    {
        return $this->int;
    }

    /**
     * Sets a new int
     *
     * @param integer $int
     * @return self
     */
    public function setInt($int)
    {
        $this->int = $int;
        return $this;
    }

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

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

    /**
     * Gets as timeOfDay
     *
     * @return \DateTime
     */
    public function getTimeOfDay()
    {
        return $this->timeOfDay;
    }

    /**
     * Sets a new timeOfDay
     *
     * @param \DateTime $timeOfDay
     * @return self
     */
    public function setTimeOfDay(\DateTime $timeOfDay)
    {
        $this->timeOfDay = $timeOfDay;
        return $this;
    }

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

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

    /**
     * Gets as apply
     *
     * @return \MetadataV4\edm\TApplyExpressionType
     */
    public function getApply()
    {
        return $this->apply;
    }

    /**
     * Sets a new apply
     *
     * @param \MetadataV4\edm\TApplyExpressionType $apply
     * @return self
     */
    public function setApply(\MetadataV4\edm\TApplyExpressionType $apply)
    {
        $this->apply = $apply;
        return $this;
    }

    /**
     * Gets as cast
     *
     * @return \MetadataV4\edm\TCastOrIsOfExpressionType
     */
    public function getCast()
    {
        return $this->cast;
    }

    /**
     * Sets a new cast
     *
     * @param \MetadataV4\edm\TCastOrIsOfExpressionType $cast
     * @return self
     */
    public function setCast(\MetadataV4\edm\TCastOrIsOfExpressionType $cast)
    {
        $this->cast = $cast;
        return $this;
    }

    /**
     * Gets as collection
     *
     * @return \MetadataV4\edm\TCollectionExpressionType
     */
    public function getCollection()
    {
        return $this->collection;
    }

    /**
     * Sets a new collection
     *
     * @param \MetadataV4\edm\TCollectionExpressionType $collection
     * @return self
     */
    public function setCollection(\MetadataV4\edm\TCollectionExpressionType $collection)
    {
        $this->collection = $collection;
        return $this;
    }

    /**
     * Gets as if
     *
     * @return \MetadataV4\edm\TIfExpressionType
     */
    public function getIf()
    {
        return $this->if;
    }

    /**
     * Sets a new if
     *
     * @param \MetadataV4\edm\TIfExpressionType $if
     * @return self
     */
    public function setIf(\MetadataV4\edm\TIfExpressionType $if)
    {
        $this->if = $if;
        return $this;
    }

    /**
     * Gets as eq
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getEq()
    {
        return $this->eq;
    }

    /**
     * Sets a new eq
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $eq
     * @return self
     */
    public function setEq(\MetadataV4\edm\TTwoChildrenExpressionType $eq)
    {
        $this->eq = $eq;
        return $this;
    }

    /**
     * Gets as ne
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getNe()
    {
        return $this->ne;
    }

    /**
     * Sets a new ne
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $ne
     * @return self
     */
    public function setNe(\MetadataV4\edm\TTwoChildrenExpressionType $ne)
    {
        $this->ne = $ne;
        return $this;
    }

    /**
     * Gets as ge
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getGe()
    {
        return $this->ge;
    }

    /**
     * Sets a new ge
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $ge
     * @return self
     */
    public function setGe(\MetadataV4\edm\TTwoChildrenExpressionType $ge)
    {
        $this->ge = $ge;
        return $this;
    }

    /**
     * Gets as gt
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getGt()
    {
        return $this->gt;
    }

    /**
     * Sets a new gt
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $gt
     * @return self
     */
    public function setGt(\MetadataV4\edm\TTwoChildrenExpressionType $gt)
    {
        $this->gt = $gt;
        return $this;
    }

    /**
     * Gets as le
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getLe()
    {
        return $this->le;
    }

    /**
     * Sets a new le
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $le
     * @return self
     */
    public function setLe(\MetadataV4\edm\TTwoChildrenExpressionType $le)
    {
        $this->le = $le;
        return $this;
    }

    /**
     * Gets as lt
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getLt()
    {
        return $this->lt;
    }

    /**
     * Sets a new lt
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $lt
     * @return self
     */
    public function setLt(\MetadataV4\edm\TTwoChildrenExpressionType $lt)
    {
        $this->lt = $lt;
        return $this;
    }

    /**
     * Gets as and
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getAnd()
    {
        return $this->and;
    }

    /**
     * Sets a new and
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $and
     * @return self
     */
    public function setAnd(\MetadataV4\edm\TTwoChildrenExpressionType $and)
    {
        $this->and = $and;
        return $this;
    }

    /**
     * Gets as or
     *
     * @return \MetadataV4\edm\TTwoChildrenExpressionType
     */
    public function getOr()
    {
        return $this->or;
    }

    /**
     * Sets a new or
     *
     * @param \MetadataV4\edm\TTwoChildrenExpressionType $or
     * @return self
     */
    public function setOr(\MetadataV4\edm\TTwoChildrenExpressionType $or)
    {
        $this->or = $or;
        return $this;
    }

    /**
     * Gets as not
     *
     * @return \MetadataV4\edm\TOneChildExpressionType
     */
    public function getNot()
    {
        return $this->not;
    }

    /**
     * Sets a new not
     *
     * @param \MetadataV4\edm\TOneChildExpressionType $not
     * @return self
     */
    public function setNot(\MetadataV4\edm\TOneChildExpressionType $not)
    {
        $this->not = $not;
        return $this;
    }

    /**
     * Gets as isOf
     *
     * @return \MetadataV4\edm\TCastOrIsOfExpressionType
     */
    public function getIsOf()
    {
        return $this->isOf;
    }

    /**
     * Sets a new isOf
     *
     * @param \MetadataV4\edm\TCastOrIsOfExpressionType $isOf
     * @return self
     */
    public function setIsOf(\MetadataV4\edm\TCastOrIsOfExpressionType $isOf)
    {
        $this->isOf = $isOf;
        return $this;
    }

    /**
     * Gets as labeledElement
     *
     * @return \MetadataV4\edm\TLabeledElementExpressionType
     */
    public function getLabeledElement()
    {
        return $this->labeledElement;
    }

    /**
     * Sets a new labeledElement
     *
     * @param \MetadataV4\edm\TLabeledElementExpressionType $labeledElement
     * @return self
     */
    public function setLabeledElement(\MetadataV4\edm\TLabeledElementExpressionType $labeledElement)
    {
        $this->labeledElement = $labeledElement;
        return $this;
    }

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

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

    /**
     * Adds as annotation
     *
     * @return self
     * @param \MetadataV4\edm\Annotation $annotation
     */
    public function addToNull(\MetadataV4\edm\Annotation $annotation)
    {
        $this->null[] = $annotation;
        return $this;
    }

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

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

    /**
     * Gets as null
     *
     * @return \MetadataV4\edm\Annotation[]
     */
    public function getNull()
    {
        return $this->null;
    }

    /**
     * Sets a new null
     *
     * @param \MetadataV4\edm\Annotation[] $null
     * @return self
     */
    public function setNull(array $null)
    {
        $this->null = $null;
        return $this;
    }

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

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

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

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

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

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

    /**
     * Gets as record
     *
     * @return \MetadataV4\edm\TRecordExpressionType
     */
    public function getRecord()
    {
        return $this->record;
    }

    /**
     * Sets a new record
     *
     * @param \MetadataV4\edm\TRecordExpressionType $record
     * @return self
     */
    public function setRecord(\MetadataV4\edm\TRecordExpressionType $record)
    {
        $this->record = $record;
        return $this;
    }

    /**
     * Gets as urlRef
     *
     * @return \MetadataV4\edm\TOneChildExpressionType
     */
    public function getUrlRef()
    {
        return $this->urlRef;
    }

    /**
     * Sets a new urlRef
     *
     * @param \MetadataV4\edm\TOneChildExpressionType $urlRef
     * @return self
     */
    public function setUrlRef(\MetadataV4\edm\TOneChildExpressionType $urlRef)
    {
        $this->urlRef = $urlRef;
        return $this;
    }
}


1			<?php
2
3			namespace AlgoWeb\ODataMetadata\MetadataV4\edm;
4
5			/**
6			* Class representing TOneChildExpressionType
7			*
8			*
9			* XSD Type: TOneChildExpression
10			*/
11			class TOneChildExpressionType
12			{
13
14			/**
15			* @property \MetadataV4\edm\Annotation[] $annotation
16			*/
17			private $annotation = array(
18
19			);
20
21			/**
22			* @property string $binary
23			*/
24			private $binary = null;
25
26			/**
27			* @property boolean $bool
28			*/
29			private $bool = null;
30
31			/**
32			* @property \DateTime $date
33			*/
34			private $date = null;
35
36			/**
37			* @property \DateTime $dateTimeOffset
38			*/
39			private $dateTimeOffset = null;
40
41			/**
42			* @property float $decimal
43			*/
44			private $decimal = null;
45
46			/**
47			* @property \DateInterval $duration
48			*/
49			private $duration = null;
50
51			/**
52			* @property string[] $enumMember
53			*/
54			private $enumMember = null;
55
56			/**
57			* @property float $float
58			*/
59			private $float = null;
60
61			/**
62			* @property string $guid
63			*/
64			private $guid = null;
65
66			/**
67			* @property integer $int
68			*/
69			private $int = null;
70
71			/**
72			* @property string $string
73			*/
74			private $string = null;
75
76			/**
77			* @property \DateTime $timeOfDay
78			*/
79			private $timeOfDay = null;
80
81			/**
82			* @property string $annotationPath
83			*/
84			private $annotationPath = null;
85
86			/**
87			* @property \MetadataV4\edm\TApplyExpressionType $apply
88			*/
89			private $apply = null;
90
91			/**
92			* @property \MetadataV4\edm\TCastOrIsOfExpressionType $cast
93			*/
94			private $cast = null;
95
96			/**
97			* @property \MetadataV4\edm\TCollectionExpressionType $collection
98			*/
99			private $collection = null;
100
101			/**
102			* @property \MetadataV4\edm\TIfExpressionType $if
103			*/
104			private $if = null;
105
106			/**
107			* @property \MetadataV4\edm\TTwoChildrenExpressionType $eq
108			*/
109			private $eq = null;
110
111			/**
112			* @property \MetadataV4\edm\TTwoChildrenExpressionType $ne
113			*/
114			private $ne = null;
115
116			/**
117			* @property \MetadataV4\edm\TTwoChildrenExpressionType $ge
118			*/
119			private $ge = null;
120
121			/**
122			* @property \MetadataV4\edm\TTwoChildrenExpressionType $gt
123			*/
124			private $gt = null;
125
126			/**
127			* @property \MetadataV4\edm\TTwoChildrenExpressionType $le
128			*/
129			private $le = null;
130
131			/**
132			* @property \MetadataV4\edm\TTwoChildrenExpressionType $lt
133			*/
134			private $lt = null;
135
136			/**
137			* @property \MetadataV4\edm\TTwoChildrenExpressionType $and
138			*/
139			private $and = null;
140
141			/**
142			* @property \MetadataV4\edm\TTwoChildrenExpressionType $or
143			*/
144			private $or = null;
145
146			/**
147			* @property \MetadataV4\edm\TOneChildExpressionType $not
148			*/
149			private $not = null;
150
151			/**
152			* @property \MetadataV4\edm\TCastOrIsOfExpressionType $isOf
153			*/
154			private $isOf = null;
155
156			/**
157			* @property \MetadataV4\edm\TLabeledElementExpressionType $labeledElement
158			*/
159			private $labeledElement = null;
160
161			/**
162			* @property string $labeledElementReference
163			*/
164			private $labeledElementReference = null;
165
166			/**
167			* @property \MetadataV4\edm\Annotation[] $null
168			*/
169			private $null = null;
170
171			/**
172			* @property string $navigationPropertyPath
173			*/
174			private $navigationPropertyPath = null;
175
176			/**
177			* @property string $path
178			*/
179			private $path = null;
180
181			/**
182			* @property string $propertyPath
183			*/
184			private $propertyPath = null;
185
186			/**
187			* @property \MetadataV4\edm\TRecordExpressionType $record
188			*/
189			private $record = null;
190
191			/**
192			* @property \MetadataV4\edm\TOneChildExpressionType $urlRef
193			*/
194			private $urlRef = null;
195
196			/**
197			* Adds as annotation
198			*
199			* @return self
200			* @param \MetadataV4\edm\Annotation $annotation
201			*/
202			public function addToAnnotation(\MetadataV4\edm\Annotation $annotation)
203			{
204			$this->annotation[] = $annotation;
205			return $this;
206			}
207
208			/**
209			* isset annotation
210			*
211			* @param scalar $index
212			* @return boolean
213			*/
214			public function issetAnnotation($index)
215			{
216			return isset($this->annotation[$index]);
217			}
218
219			/**
220			* unset annotation
221			*
222			* @param scalar $index
223			* @return void
224			*/
225			public function unsetAnnotation($index)
226			{
227			unset($this->annotation[$index]);
228			}
229
230			/**
231			* Gets as annotation
232			*
233			* @return \MetadataV4\edm\Annotation[]
234			*/
235			public function getAnnotation()
236			{
237			return $this->annotation;
238			}
239
240			/**
241			* Sets a new annotation
242			*
243			* @param \MetadataV4\edm\Annotation[] $annotation
244			* @return self
245			*/
246			public function setAnnotation(array $annotation)
247			{
248			$this->annotation = $annotation;
249			return $this;
250			}
251
252			/**
253			* Gets as binary
254			*
255			* @return string
256			*/
257			public function getBinary()
258			{
259			return $this->binary;
260			}
261
262			/**
263			* Sets a new binary
264			*
265			* @param string $binary
266			* @return self
267			*/
268			public function setBinary($binary)
269			{
270			$this->binary = $binary;
271			return $this;
272			}
273
274			/**
275			* Gets as bool
276			*
277			* @return boolean
278			*/
279			public function getBool()
280			{
281			return $this->bool;
282			}
283
284			/**
285			* Sets a new bool
286			*
287			* @param boolean $bool
288			* @return self
289			*/
290			public function setBool($bool)
291			{
292			$this->bool = $bool;
293			return $this;
294			}
295
296			/**
297			* Gets as date
298			*
299			* @return \DateTime
300			*/
301			public function getDate()
302			{
303			return $this->date;
304			}
305
306			/**
307			* Sets a new date
308			*
309			* @param \DateTime $date
310			* @return self
311			*/
312			public function setDate(\DateTime $date)
313			{
314			$this->date = $date;
315			return $this;
316			}
317
318			/**
319			* Gets as dateTimeOffset
320			*
321			* @return \DateTime
322			*/
323			public function getDateTimeOffset()
324			{
325			return $this->dateTimeOffset;
326			}
327
328			/**
329			* Sets a new dateTimeOffset
330			*
331			* @param \DateTime $dateTimeOffset
332			* @return self
333			*/
334			public function setDateTimeOffset(\DateTime $dateTimeOffset)
335			{
336			$this->dateTimeOffset = $dateTimeOffset;
337			return $this;
338			}
339
340			/**
341			* Gets as decimal
342			*
343			* @return float
344			*/
345			public function getDecimal()
346			{
347			return $this->decimal;
348			}
349
350			/**
351			* Sets a new decimal
352			*
353			* @param float $decimal
354			* @return self
355			*/
356			public function setDecimal($decimal)
357			{
358			$this->decimal = $decimal;
359			return $this;
360			}
361
362			/**
363			* Gets as duration
364			*
365			* @return \DateInterval
366			*/
367			public function getDuration()
368			{
369			return $this->duration;
370			}
371
372			/**
373			* Sets a new duration
374			*
375			* @param \DateInterval $duration
376			* @return self
377			*/
378			public function setDuration(\DateInterval $duration)
379			{
380			$this->duration = $duration;
381			return $this;
382			}
383
384			/**
385			* Adds as enumMember
386			*
387			* @return self
388			* @param string $enumMember
389			*/
390			public function addToEnumMember($enumMember)
391			{
392			$this->enumMember[] = $enumMember;
393			return $this;
394			}
395
396			/**
397			* isset enumMember
398			*
399			* @param scalar $index
400			* @return boolean
401			*/
402			public function issetEnumMember($index)
403			{
404			return isset($this->enumMember[$index]);
405			}
406
407			/**
408			* unset enumMember
409			*
410			* @param scalar $index
411			* @return void
412			*/
413			public function unsetEnumMember($index)
414			{
415			unset($this->enumMember[$index]);
416			}
417
418			/**
419			* Gets as enumMember
420			*
421			* @return string[]
422			*/
423			public function getEnumMember()
424			{
425			return $this->enumMember;
426			}
427
428			/**
429			* Sets a new enumMember
430			*
431			* @param string $enumMember
432			* @return self
433			*/
434			public function setEnumMember(array $enumMember)
435			{
436			$this->enumMember = $enumMember;
437			return $this;
438			}
439
440			/**
441			* Gets as float
442			*
443			* @return float
444			*/
445			public function getFloat()
446			{
447			return $this->float;
448			}
449
450			/**
451			* Sets a new float
452			*
453			* @param float $float
454			* @return self
455			*/
456			public function setFloat($float)
457			{
458			$this->float = $float;
459			return $this;
460			}
461
462			/**
463			* Gets as guid
464			*
465			* @return string
466			*/
467			public function getGuid()
468			{
469			return $this->guid;
470			}
471
472			/**
473			* Sets a new guid
474			*
475			* @param string $guid
476			* @return self
477			*/
478			public function setGuid($guid)
479			{
480			$this->guid = $guid;
481			return $this;
482			}
483
484			/**
485			* Gets as int
486			*
487			* @return integer
488			*/
489			public function getInt()
490			{
491			return $this->int;
492			}
493
494			/**
495			* Sets a new int
496			*
497			* @param integer $int
498			* @return self
499			*/
500			public function setInt($int)
501			{
502			$this->int = $int;
503			return $this;
504			}
505
506			/**
507			* Gets as string
508			*
509			* @return string
510			*/
511			public function getString()
512			{
513			return $this->string;
514			}
515
516			/**
517			* Sets a new string
518			*
519			* @param string $string
520			* @return self
521			*/
522			public function setString($string)
523			{
524			$this->string = $string;
525			return $this;
526			}
527
528			/**
529			* Gets as timeOfDay
530			*
531			* @return \DateTime
532			*/
533			public function getTimeOfDay()
534			{
535			return $this->timeOfDay;
536			}
537
538			/**
539			* Sets a new timeOfDay
540			*
541			* @param \DateTime $timeOfDay
542			* @return self
543			*/
544			public function setTimeOfDay(\DateTime $timeOfDay)
545			{
546			$this->timeOfDay = $timeOfDay;
547			return $this;
548			}
549
550			/**
551			* Gets as annotationPath
552			*
553			* @return string
554			*/
555			public function getAnnotationPath()
556			{
557			return $this->annotationPath;
558			}
559
560			/**
561			* Sets a new annotationPath
562			*
563			* @param string $annotationPath
564			* @return self
565			*/
566			public function setAnnotationPath($annotationPath)
567			{
568			$this->annotationPath = $annotationPath;
569			return $this;
570			}
571
572			/**
573			* Gets as apply
574			*
575			* @return \MetadataV4\edm\TApplyExpressionType
576			*/
577			public function getApply()
578			{
579			return $this->apply;
580			}
581
582			/**
583			* Sets a new apply
584			*
585			* @param \MetadataV4\edm\TApplyExpressionType $apply
586			* @return self
587			*/
588			public function setApply(\MetadataV4\edm\TApplyExpressionType $apply)
589			{
590			$this->apply = $apply;
591			return $this;
592			}
593
594			/**
595			* Gets as cast
596			*
597			* @return \MetadataV4\edm\TCastOrIsOfExpressionType
598			*/
599			public function getCast()
600			{
601			return $this->cast;
602			}
603
604			/**
605			* Sets a new cast
606			*
607			* @param \MetadataV4\edm\TCastOrIsOfExpressionType $cast
608			* @return self
609			*/
610			public function setCast(\MetadataV4\edm\TCastOrIsOfExpressionType $cast)
611			{
612			$this->cast = $cast;
613			return $this;
614			}
615
616			/**
617			* Gets as collection
618			*
619			* @return \MetadataV4\edm\TCollectionExpressionType
620			*/
621			public function getCollection()
622			{
623			return $this->collection;
624			}
625
626			/**
627			* Sets a new collection
628			*
629			* @param \MetadataV4\edm\TCollectionExpressionType $collection
630			* @return self
631			*/
632			public function setCollection(\MetadataV4\edm\TCollectionExpressionType $collection)
633			{
634			$this->collection = $collection;
635			return $this;
636			}
637
638			/**
639			* Gets as if
640			*
641			* @return \MetadataV4\edm\TIfExpressionType
642			*/
643			public function getIf()
644			{
645			return $this->if;
646			}
647
648			/**
649			* Sets a new if
650			*
651			* @param \MetadataV4\edm\TIfExpressionType $if
652			* @return self
653			*/
654			public function setIf(\MetadataV4\edm\TIfExpressionType $if)
655			{
656			$this->if = $if;
657			return $this;
658			}
659
660			/**
661			* Gets as eq
662			*
663			* @return \MetadataV4\edm\TTwoChildrenExpressionType
664			*/
665			public function getEq()
666			{
667			return $this->eq;
668			}
669
670			/**
671			* Sets a new eq
672			*
673			* @param \MetadataV4\edm\TTwoChildrenExpressionType $eq
674			* @return self
675			*/
676			public function setEq(\MetadataV4\edm\TTwoChildrenExpressionType $eq)
677			{
678			$this->eq = $eq;
679			return $this;
680			}
681
682			/**
683			* Gets as ne
684			*
685			* @return \MetadataV4\edm\TTwoChildrenExpressionType
686			*/
687			public function getNe()
688			{
689			return $this->ne;
690			}
691
692			/**
693			* Sets a new ne
694			*
695			* @param \MetadataV4\edm\TTwoChildrenExpressionType $ne
696			* @return self
697			*/
698			public function setNe(\MetadataV4\edm\TTwoChildrenExpressionType $ne)
699			{
700			$this->ne = $ne;
701			return $this;
702			}
703
704			/**
705			* Gets as ge
706			*
707			* @return \MetadataV4\edm\TTwoChildrenExpressionType
708			*/
709			public function getGe()
710			{
711			return $this->ge;
712			}
713
714			/**
715			* Sets a new ge
716			*
717			* @param \MetadataV4\edm\TTwoChildrenExpressionType $ge
718			* @return self
719			*/
720			public function setGe(\MetadataV4\edm\TTwoChildrenExpressionType $ge)
721			{
722			$this->ge = $ge;
723			return $this;
724			}
725
726			/**
727			* Gets as gt
728			*
729			* @return \MetadataV4\edm\TTwoChildrenExpressionType
730			*/
731			public function getGt()
732			{
733			return $this->gt;
734			}
735
736			/**
737			* Sets a new gt
738			*
739			* @param \MetadataV4\edm\TTwoChildrenExpressionType $gt
740			* @return self
741			*/
742			public function setGt(\MetadataV4\edm\TTwoChildrenExpressionType $gt)
743			{
744			$this->gt = $gt;
745			return $this;
746			}
747
748			/**
749			* Gets as le
750			*
751			* @return \MetadataV4\edm\TTwoChildrenExpressionType
752			*/
753			public function getLe()
754			{
755			return $this->le;
756			}
757
758			/**
759			* Sets a new le
760			*
761			* @param \MetadataV4\edm\TTwoChildrenExpressionType $le
762			* @return self
763			*/
764			public function setLe(\MetadataV4\edm\TTwoChildrenExpressionType $le)
765			{
766			$this->le = $le;
767			return $this;
768			}
769
770			/**
771			* Gets as lt
772			*
773			* @return \MetadataV4\edm\TTwoChildrenExpressionType
774			*/
775			public function getLt()
776			{
777			return $this->lt;
778			}
779
780			/**
781			* Sets a new lt
782			*
783			* @param \MetadataV4\edm\TTwoChildrenExpressionType $lt
784			* @return self
785			*/
786			public function setLt(\MetadataV4\edm\TTwoChildrenExpressionType $lt)
787			{
788			$this->lt = $lt;
789			return $this;
790			}
791
792			/**
793			* Gets as and
794			*
795			* @return \MetadataV4\edm\TTwoChildrenExpressionType
796			*/
797			public function getAnd()
798			{
799			return $this->and;
800			}
801
802			/**
803			* Sets a new and
804			*
805			* @param \MetadataV4\edm\TTwoChildrenExpressionType $and
806			* @return self
807			*/
808			public function setAnd(\MetadataV4\edm\TTwoChildrenExpressionType $and)
809			{
810			$this->and = $and;
811			return $this;
812			}
813
814			/**
815			* Gets as or
816			*
817			* @return \MetadataV4\edm\TTwoChildrenExpressionType
818			*/
819			public function getOr()
820			{
821			return $this->or;
822			}
823
824			/**
825			* Sets a new or
826			*
827			* @param \MetadataV4\edm\TTwoChildrenExpressionType $or
828			* @return self
829			*/
830			public function setOr(\MetadataV4\edm\TTwoChildrenExpressionType $or)
831			{
832			$this->or = $or;
833			return $this;
834			}
835
836			/**
837			* Gets as not
838			*
839			* @return \MetadataV4\edm\TOneChildExpressionType
840			*/
841			public function getNot()
842			{
843			return $this->not;
844			}
845
846			/**
847			* Sets a new not
848			*
849			* @param \MetadataV4\edm\TOneChildExpressionType $not
850			* @return self
851			*/
852			public function setNot(\MetadataV4\edm\TOneChildExpressionType $not)
853			{
854			$this->not = $not;
855			return $this;
856			}
857
858			/**
859			* Gets as isOf
860			*
861			* @return \MetadataV4\edm\TCastOrIsOfExpressionType
862			*/
863			public function getIsOf()
864			{
865			return $this->isOf;
866			}
867
868			/**
869			* Sets a new isOf
870			*
871			* @param \MetadataV4\edm\TCastOrIsOfExpressionType $isOf
872			* @return self
873			*/
874			public function setIsOf(\MetadataV4\edm\TCastOrIsOfExpressionType $isOf)
875			{
876			$this->isOf = $isOf;
877			return $this;
878			}
879
880			/**
881			* Gets as labeledElement
882			*
883			* @return \MetadataV4\edm\TLabeledElementExpressionType
884			*/
885			public function getLabeledElement()
886			{
887			return $this->labeledElement;
888			}
889
890			/**
891			* Sets a new labeledElement
892			*
893			* @param \MetadataV4\edm\TLabeledElementExpressionType $labeledElement
894			* @return self
895			*/
896			public function setLabeledElement(\MetadataV4\edm\TLabeledElementExpressionType $labeledElement)
897			{
898			$this->labeledElement = $labeledElement;
899			return $this;
900			}
901
902			/**
903			* Gets as labeledElementReference
904			*
905			* @return string
906			*/
907			public function getLabeledElementReference()
908			{
909			return $this->labeledElementReference;
910			}
911
912			/**
913			* Sets a new labeledElementReference
914			*
915			* @param string $labeledElementReference
916			* @return self
917			*/
918			public function setLabeledElementReference($labeledElementReference)
919			{
920			$this->labeledElementReference = $labeledElementReference;
921			return $this;
922			}
923
924			/**
925			* Adds as annotation
926			*
927			* @return self
928			* @param \MetadataV4\edm\Annotation $annotation
929			*/
930			public function addToNull(\MetadataV4\edm\Annotation $annotation)
931			{
932			$this->null[] = $annotation;
933			return $this;
934			}
935
936			/**
937			* isset null
938			*
939			* @param scalar $index
940			* @return boolean
941			*/
942			public function issetNull($index)
943			{
944			return isset($this->null[$index]);
945			}
946
947			/**
948			* unset null
949			*
950			* @param scalar $index
951			* @return void
952			*/
953			public function unsetNull($index)
954			{
955			unset($this->null[$index]);
956			}
957
958			/**
959			* Gets as null
960			*
961			* @return \MetadataV4\edm\Annotation[]
962			*/
963			public function getNull()
964			{
965			return $this->null;
966			}
967
968			/**
969			* Sets a new null
970			*
971			* @param \MetadataV4\edm\Annotation[] $null
972			* @return self
973			*/
974			public function setNull(array $null)
975			{
976			$this->null = $null;
977			return $this;
978			}
979
980			/**
981			* Gets as navigationPropertyPath
982			*
983			* @return string
984			*/
985			public function getNavigationPropertyPath()
986			{
987			return $this->navigationPropertyPath;
988			}
989
990			/**
991			* Sets a new navigationPropertyPath
992			*
993			* @param string $navigationPropertyPath
994			* @return self
995			*/
996			public function setNavigationPropertyPath($navigationPropertyPath)
997			{
998			$this->navigationPropertyPath = $navigationPropertyPath;
999			return $this;
1000			}
1001
1002			/**
1003			* Gets as path
1004			*
1005			* @return string
1006			*/
1007			public function getPath()
1008			{
1009			return $this->path;
1010			}
1011
1012			/**
1013			* Sets a new path
1014			*
1015			* @param string $path
1016			* @return self
1017			*/
1018			public function setPath($path)
1019			{
1020			$this->path = $path;
1021			return $this;
1022			}
1023
1024			/**
1025			* Gets as propertyPath
1026			*
1027			* @return string
1028			*/
1029			public function getPropertyPath()
1030			{
1031			return $this->propertyPath;
1032			}
1033
1034			/**
1035			* Sets a new propertyPath
1036			*
1037			* @param string $propertyPath
1038			* @return self
1039			*/
1040			public function setPropertyPath($propertyPath)
1041			{
1042			$this->propertyPath = $propertyPath;
1043			return $this;
1044			}
1045
1046			/**
1047			* Gets as record
1048			*
1049			* @return \MetadataV4\edm\TRecordExpressionType
1050			*/
1051			public function getRecord()
1052			{
1053			return $this->record;
1054			}
1055
1056			/**
1057			* Sets a new record
1058			*
1059			* @param \MetadataV4\edm\TRecordExpressionType $record
1060			* @return self
1061			*/
1062			public function setRecord(\MetadataV4\edm\TRecordExpressionType $record)
1063			{
1064			$this->record = $record;
1065			return $this;
1066			}
1067
1068			/**
1069			* Gets as urlRef
1070			*
1071			* @return \MetadataV4\edm\TOneChildExpressionType
1072			*/
1073			public function getUrlRef()
1074			{
1075			return $this->urlRef;
1076			}
1077
1078			/**
1079			* Sets a new urlRef
1080			*
1081			* @param \MetadataV4\edm\TOneChildExpressionType $urlRef
1082			* @return self
1083			*/
1084			public function setUrlRef(\MetadataV4\edm\TOneChildExpressionType $urlRef)
1085			{
1086			$this->urlRef = $urlRef;
1087			return $this;
1088			}
1089			}
1090

Algo-Web / ODataMetadata

Push — master ( 583371...613693 )

TOneChildExpressionType::addToAnnotation() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like