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

TCastOrIsOfExpressionType D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	1214
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	0

Importance

Changes

Metric	Value
wmc	91
lcom	3
cbo	0
dl	0
loc	1214
rs	4.4102
c	0
b	0
f	0

91 Methods

Rating	Name	Size	Complexity
A	getType()	4	1
A	setType()	5	1
A	getMaxLength()	4	1
A	setMaxLength()	5	1
A	getPrecision()	4	1
A	setPrecision()	5	1
A	getScale()	4	1
A	setScale()	5	1
A	getSRID()	4	1
A	setSRID()	5	1
A	addToAnnotation()	5	1
A	issetAnnotation()	4	1
A	unsetAnnotation()	4	1
A	getAnnotation()	4	1
A	setAnnotation()	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	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	getNavigationPropertyPath()	4	1
A	setNavigationPropertyPath()	5	1
A	getPath()	4	1
A	setPath()	5	1
A	getPropertyPath()	4	1
A	setPropertyPath()	5	1
A	getRecord()	4	1
A	setRecord()	5	1
A	getUrlRef()	4	1
A	setUrlRef()	5	1

How to fix Complexity

<?php

namespace AlgoWeb\ODataMetadata\MetadataV4\edm;

/**
 * Class representing TCastOrIsOfExpressionType
 *
 *
 * XSD Type: TCastOrIsOfExpression
 */
class TCastOrIsOfExpressionType
{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

Algo-Web / ODataMetadata

Push — master ( 583371...613693 )

TCastOrIsOfExpressionType D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

91 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like