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

TLabeledElementExpressionType D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	1106
Duplicated Lines	100 %

Coupling/Cohesion

Components	3
Dependencies	0

Importance

Changes

Metric	Value
wmc	83
lcom	3
cbo	0
dl	1106
loc	1106
rs	4.4102
c	0
b	0
f	0

83 Methods

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

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like TLabeledElementExpressionType often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use TLabeledElementExpressionType, and based on these observations, apply Extract Interface, too.

<?php

namespace AlgoWeb\ODataMetadata\MetadataV4\edm;

/**
 * Class representing TLabeledElementExpressionType
 *
 *
 * XSD Type: TLabeledElementExpression
 */
class TLabeledElementExpressionType

{

    /**
     * @property string $name
     */
    private $name = 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 name
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

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

Algo-Web / ODataMetadata