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

Annotation D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	1133
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	0

Importance

Changes

Metric	Value
wmc	85
lcom	3
cbo	0
dl	0
loc	1133
rs	4.4102
c	0
b	0
f	0

85 Methods

Rating	Name	Size	Complexity
A	getTerm()	4	1
A	setTerm()	5	1
A	getQualifier()	4	1
A	setQualifier()	5	1
A	getBinary()	4	1
A	setBinary()	5	1
A	getBool()	4	1
A	setBool()	5	1
A	getDate()	4	1
A	setDate()	5	1
A	getDateTimeOffset()	4	1
A	setDateTimeOffset()	5	1
A	getDecimal()	4	1
A	setDecimal()	5	1
A	getDuration()	4	1
A	setDuration()	5	1
A	addToEnumMember()	5	1
A	issetEnumMember()	4	1
A	unsetEnumMember()	4	1
A	getEnumMember()	4	1
A	setEnumMember()	5	1
A	getFloat()	4	1
A	setFloat()	5	1
A	getGuid()	4	1
A	setGuid()	5	1
A	getInt()	4	1
A	setInt()	5	1
A	getString()	4	1
A	setString()	5	1
A	getTimeOfDay()	4	1
A	setTimeOfDay()	5	1
A	getAnnotationPath()	4	1
A	setAnnotationPath()	5	1
A	getNavigationPropertyPath()	4	1
A	setNavigationPropertyPath()	5	1
A	getPath()	4	1
A	setPath()	5	1
A	getPropertyPath()	4	1
A	setPropertyPath()	5	1
A	getUrlRef()	4	1
A	setUrlRef()	5	1
A	addToAnnotation()	5	1
A	issetAnnotation()	4	1
A	unsetAnnotation()	4	1
A	getAnnotation()	4	1
A	setAnnotation()	5	1
A	getApply()	4	1
A	setApply()	5	1
A	getCast()	4	1
A	setCast()	5	1
A	getCollection()	4	1
A	setCollection()	5	1
A	getIf()	4	1
A	setIf()	5	1
A	getEq()	4	1
A	setEq()	5	1
A	getNe()	4	1
A	setNe()	5	1
A	getGe()	4	1
A	setGe()	5	1
A	getGt()	4	1
A	setGt()	5	1
A	getLe()	4	1
A	setLe()	5	1
A	getLt()	4	1
A	setLt()	5	1
A	getAnd()	4	1
A	setAnd()	5	1
A	getOr()	4	1
A	setOr()	5	1
A	getNot()	4	1
A	setNot()	5	1
A	getIsOf()	4	1
A	setIsOf()	5	1
A	getLabeledElement()	4	1
A	setLabeledElement()	5	1
A	getLabeledElementReference()	4	1
A	setLabeledElementReference()	5	1
A	addToNull()	5	1
A	issetNull()	4	1
A	unsetNull()	4	1
A	getNull()	4	1
A	setNull()	5	1
A	getRecord()	4	1
A	setRecord()	5	1

How to fix Complexity

<?php

namespace AlgoWeb\ODataMetadata\MetadataV4\edm;

/**
 * Class representing Annotation
 */
class Annotation
{

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

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

    /**
     * @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 string $navigationPropertyPath
     */
    private $navigationPropertyPath = null;

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

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

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

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

    /**
     * @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 \MetadataV4\edm\TRecordExpressionType $record
     */
    private $record = null;

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

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

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

    /**
     * Sets a new qualifier
     *
     * @param string $qualifier
     * @return self
     */
    public function setQualifier($qualifier)
    {
        $this->qualifier = $qualifier;
        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 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 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;
    }

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


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

Algo-Web / ODataMetadata

Push — master ( 583371...613693 )

Annotation D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

85 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like