Struct::getValue() - Code Metrics - Inspection of "Merge branch 'release/2.8.1'" - WsdlToPhp/PackageGenerator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 060bfa...009823 )

by Mikaël

created 2017-08-12 04:15 UTC

Struct::getValue() A

↳ Parent: Struct

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php

namespace WsdlToPhp\PackageGenerator\Model;

use WsdlToPhp\PackageGenerator\Generator\Utils;
use WsdlToPhp\PackageGenerator\Container\Model\StructValue as StructValueContainer;
use WsdlToPhp\PackageGenerator\Container\Model\StructAttribute as StructAttributeContainer;
use WsdlToPhp\PackageGenerator\Generator\Generator;
use WsdlToPhp\PackageGenerator\ConfigurationReader\StructReservedMethod;
use WsdlToPhp\PackageGenerator\ConfigurationReader\StructArrayReservedMethod;

/**
 * Class Struct stands for an available struct described in the WSDL
 */
class Struct extends AbstractModel
{
    /**
     * @var string
     */
    const DOC_SUB_PACKAGE_STRUCTS = 'Structs';
    /**
     * @var string
     */
    const DOC_SUB_PACKAGE_ENUMERATIONS = 'Enumerations';
    /**
     * @var string
     */
    const DOC_SUB_PACKAGE_ARRAYS = 'Arrays';
    /**
     * Attributes of the struct
     * @var StructAttributeContainer
     */
    private $attributes;
    /**
     * Is the struct a restriction with defined values  ?
     * @var bool
     */
    private $isRestriction = false;
    /**
     * If the struct is a restriction with values, then store values
     * @var StructValueContainer
     */
    private $values;
    /**
     * If the struct is a union with types, then store types
     * @var string[]
     */
    private $types;
    /**
     * Define if the urrent struct is a concrete struct or just a virtual struct to store meta informations
     * @var bool
     */
    private $isStruct = false;
    /**
     * Main constructor
     * @see AbstractModel::__construct()
     * @uses Struct::setStruct()
     * @param Generator $generator
     * @param string $name the original name
     * @param bool $isStruct defines if it's a real sruct or not
     * @param bool $isRestriction defines if it's an enumeration or not
     */
    public function __construct(Generator $generator, $name, $isStruct = true, $isRestriction = false)
    {
        parent::__construct($generator, $name);
        $this->setStruct($isStruct)->setRestriction($isRestriction)->setAttributes(new StructAttributeContainer($generator))->setValues(new StructValueContainer($generator));
    }
    /**
     * Returns the contextual part of the class name for the package
     * @see AbstractModel::getContextualPart()
     * @uses Struct::isRestriction()
     * @return string
     */
    public function getContextualPart()
    {
        $part = $this->getGenerator()->getOptionStructsFolder();
        if ($this->isRestriction()) {
            $part = $this->getGenerator()->getOptionEnumsFolder();
        } elseif ($this->isArray()) {
            $part = $this->getGenerator()->getOptionArraysFolder();
        }
        return $part;
    }
    /**
     * Returns the sub package name which the model belongs to
     * Must be overridden by sub classes
     * @see AbstractModel::getDocSubPackages()
     * @uses Struct::isRestriction()
     * @return array
     */
    public function getDocSubPackages()
    {
        $package = self::DOC_SUB_PACKAGE_STRUCTS;
        if ($this->isRestriction()) {
            $package = self::DOC_SUB_PACKAGE_ENUMERATIONS;
        } elseif ($this->isArray()) {
            $package = self::DOC_SUB_PACKAGE_ARRAYS;
        }
        return array(
            $package,
        );
    }
    /**
     * Returns true if the current struct is a collection of values (like an array)
     * @uses AbstractModel::getName()
     * @uses Struct::countOwnAttributes()
     * @return bool
     */
    public function isArray()
    {
        return ((($this->isStruct() && $this->countOwnAttributes() === 1) || (!$this->isStruct() && $this->countOwnAttributes() <= 1)) && (stripos($this->getName(), 'array') !== false) || (!$this->isStruct() && $this->getMetaValueFirstSet(array('arraytype', 'arrayType'), false) !== false));
    }
    /**
     * Returns the attributes of the struct and potentially from the parent class
     * @uses AbstractModel::getInheritance()
     * @uses Struct::isStruct()
     * @uses Struct::getAttributes()
     * @param bool $includeInheritanceAttributes include the attributes of parent class, default parent attributes are not included. If true, then the array is an associative array containing and index "attribute" for the StructAttribute object and an index "model" for the Struct object.
     * @param bool $requiredFirst places the required attributes first, then the not required in order to have the _contrust method with the required attribute at first
     * @return StructAttributeContainer
     */
    public function getAttributes($includeInheritanceAttributes = false, $requiredFirst = false)
    {
        if ($includeInheritanceAttributes === false && $requiredFirst === false) {
            $attributes = $this->attributes;
        } else {
            $attributes = $this->getAllAttributes($includeInheritanceAttributes, $requiredFirst);
        }
        return $attributes;
    }
    /**
     * @param bool $includeInheritanceAttributes
     * @param bool $requiredFirst
     * @return StructAttributeContainer
     */
    protected function getAllAttributes($includeInheritanceAttributes, $requiredFirst)
    {
        $allAttributes = new StructAttributeContainer($this->getGenerator());
        if ($includeInheritanceAttributes === true) {
            $this->addInheritanceAttributes($allAttributes);
        }
        foreach ($this->attributes as $attribute) {
            $allAttributes->add($attribute);
        }
        if ($requiredFirst === true) {
            $attributes = $this->putRequiredFirst($allAttributes);
        } else {
            $attributes = $allAttributes;
        }
        return $attributes;
    }
    /**
     * @param StructAttributeContainer $attributes
     */
    protected function addInheritanceAttributes(StructAttributeContainer $attributes)
    {
        if ($this->getInheritance() != '' && ($model = $this->getInheritanceStruct()) instanceof Struct) {
            while ($model instanceof Struct && $model->isStruct()) {
                foreach ($model->getAttributes() as $attribute) {
                    $attributes->add($attribute);
                }
                $model = $model->getInheritanceStruct();
            }
        }
    }
    /**
     * @param StructAttributeContainer $allAttributes
     * @return StructAttributeContainer
     */
    protected function putRequiredFirst(StructAttributeContainer $allAttributes)
    {
        $attributes = new StructAttributeContainer($this->getGenerator());
        $requiredAttributes = new StructAttributeContainer($this->getGenerator());
        $notRequiredAttributes = new StructAttributeContainer($this->getGenerator());
        foreach ($allAttributes as $attribute) {
            if ($attribute->isRequired()) {
                $requiredAttributes->add($attribute);
            } else {
                $notRequiredAttributes->add($attribute);
            }
        }
        foreach ($requiredAttributes as $attribute) {
            $attributes->add($attribute);
        }
        foreach ($notRequiredAttributes as $attribute) {
            $attributes->add($attribute);
        }
        unset($requiredAttributes, $notRequiredAttributes);
        return $attributes;
    }
    /**
     * Returns the number of own attributes
     * @uses Struct::getAttributes()
     * @return int
     */
    public function countOwnAttributes()
    {
        return $this->getAttributes(false, false)->count();
    }
    /**
     * Sets the attributes of the struct
     * @param StructAttributeContainer $structAttributeContainer
     * @return Struct
     */
    public function setAttributes(StructAttributeContainer $structAttributeContainer)
    {
        $this->attributes = $structAttributeContainer;
        return $this;
    }
    /**
     * Adds attribute based on its original name
     * @throws \InvalidArgumentException
     * @param string $attributeName the attribute name
     * @param string $attributeType the attribute type
     * @return Struct
     */
    public function addAttribute($attributeName, $attributeType)
    {
        if (empty($attributeName) || empty($attributeType)) {
            throw new \InvalidArgumentException(sprintf('Attribute name "%s" and/or attribute type "%s" is invalid for Struct "%s"', $attributeName, $attributeType, $this->getName()), __LINE__);
        }
        if ($this->attributes->getStructAttributeByName($attributeName) === null) {
            $structAttribute = new StructAttribute($this->getGenerator(), $attributeName, $attributeType, $this);
            $this->attributes->add($structAttribute);
        }
        return $this;
    }
    /**
     * Returns the attribute by its name, otherwise null
     * @uses Struct::getAttributes()
     * @param string $attributeName the original attribute name
     * @return StructAttribute|null
     */
    public function getAttribute($attributeName)
    {
        return $this->attributes->getStructAttributeByName($attributeName);
    }
    /**
     * Returns the attribute by its cleaned name, otherwise null
     * @uses Struct::getAttributes()
     * @param string $attributeCleanName the cleaned attribute name
     * @return StructAttribute|null
     */
    public function getAttributeByCleanName($attributeCleanName)
    {
        return $this->attributes->getStructAttributeByCleanName($attributeCleanName);
    }
    /**
     * Returns the isRestriction value
     * @return bool
     */
    public function isRestriction()
    {
        return $this->isRestriction;
    }
    /**
     * Sets the isRestriction value
     * @param bool $isRestriction
     * @return Struct
     */
    public function setRestriction($isRestriction = true)
    {
        $this->isRestriction = $isRestriction;
        return $this;
    }
    /**
     * Returns the isStruct value
     * @return bool
     */
    public function isStruct()
    {
        return $this->isStruct;
    }
    /**
     * Sets the isStruct value
     * @param bool $isStruct
     * @return Struct
     */
    public function setStruct($isStruct = true)
    {
        $this->isStruct = $isStruct;
        return $this;
    }
    /**
     * Returns the values for an enumeration
     * @return StructValueContainer
     */
    public function getValues()
    {
        return $this->values;
    }
    /**
     * Sets the values for an enumeration
     * @param StructValueContainer $structValueContainer
     * @return Struct
     */
    protected function setValues(StructValueContainer $structValueContainer)
    {
        $this->values = $structValueContainer;
        return $this;
    }
    /**
     * Adds value to values array
     * @uses Struct::getValue()
     * @uses Struct::getValues()
     * @param mixed $value the original value
     * @return Struct
     */
    public function addValue($value)
    {
        if ($this->getValue($value) === null) {
            $this->values->add(new StructValue($this->getGenerator(), $value, $this->getValues()->count(), $this));
            $this->setRestriction(true);
            $this->setStruct(true);
        }
        return $this;
    }
    /**
     * Gets the value object for the given value
     * @uses Struct::getValues()
     * @uses AbstractModel::getName()
     * @param string $value Value name
     * @return StructValue|null
     */
    public function getValue($value)
    {
        return $this->values->getStructValueByName($value);
    }
    /**
     * Allows to define from which class the curent model extends
     * @param bool $short
     * @return string
     */
    public function getExtends($short = false)
    {
        $extends = '';
        if ($this->isArray()) {
            $extends = $this->getGenerator()->getOptionStructArrayClass();
        } elseif (!$this->isRestriction()) {
            $extends = $this->getGenerator()->getOptionStructClass();
        }
        return $short ? Utils::removeNamespace($extends) : $extends;
    }
    /**
     * @return Struct|null
     */
    public function getInheritanceStruct()
    {
        return $this->getGenerator()->getStruct(str_replace('[]', '', $this->getInheritance()));
    }
    /**
     * @return string
     */
    public function getTopInheritance()
    {
        $inheritance = $this->getInheritance();
        if (!empty($inheritance)) {
            $struct = $this->getInheritanceStruct();
            while ($struct instanceof Struct) {
                $structInheritance = $struct->getInheritance();
                if (!empty($structInheritance)) {
                    $inheritance = $structInheritance;
                }
                $struct = $struct->getInheritanceStruct();
            }
        }
        return $inheritance;
    }
    /**
     * @see \WsdlToPhp\PackageGenerator\Model\AbstractModel::getMeta()
     * @return string[]
     */
    public function getMeta()
    {
        $inheritanceStruct = $this->getInheritanceStruct();
        return array_merge_recursive(parent::getMeta(), ($inheritanceStruct && !$inheritanceStruct->isStruct()) ? $inheritanceStruct->getMeta() : array());
    }
    /**
     * @param $filename
     * @return StructReservedMethod|StructArrayReservedMethod
     */
    public function getReservedMethodsInstance($filename = null)
    {
        $instance = StructReservedMethod::instance($filename);
        if ($this->isArray()) {
            $instance = StructArrayReservedMethod::instance($filename);
        }
        return $instance;
    }
    /**
     * @return string[]
     */
    public function getTypes()
    {
        return $this->types;
    }
    /**
     * @return boolean
     */
    public function isUnion()
    {
        return count($this->types) > 0;
    }
    /**
     * @param string[] $types
     * @return Struct
     */
    public function setTypes($types)
    {
        $this->types = $types;
        return $this;
    }
    /**
     * {@inheritDoc}
     * @see \WsdlToPhp\PackageGenerator\Model\AbstractModel::toJsonSerialize()
     */
    protected function toJsonSerialize()
    {
        return array(
            'attributes' => $this->attributes,
            'restriction' => $this->isRestriction,
            'struct' => $this->isStruct,
            'types' => $this->types,
            'values' => $this->values,
        );
    }
    /**
     * @param array $attributes
     */
    public function setAttributesFromSerializedJson(array $attributes)
    {
        foreach ($attributes as $attribute) {
            $this->attributes->add(self::instanceFromSerializedJson($this->generator, $attribute)->setOwner($this));
        }
    }
    /**
     * @param array $values
     */
    public function setValuesFromSerializedJson(array $values)
    {
        foreach ($values as $value) {
            $this->values->add(self::instanceFromSerializedJson($this->generator, $value)->setOwner($this));
        }
    }
}


1		<?php
2
3		namespace WsdlToPhp\PackageGenerator\Model;
4
5		use WsdlToPhp\PackageGenerator\Generator\Utils;
6		use WsdlToPhp\PackageGenerator\Container\Model\StructValue as StructValueContainer;
7		use WsdlToPhp\PackageGenerator\Container\Model\StructAttribute as StructAttributeContainer;
8		use WsdlToPhp\PackageGenerator\Generator\Generator;
9		use WsdlToPhp\PackageGenerator\ConfigurationReader\StructReservedMethod;
10		use WsdlToPhp\PackageGenerator\ConfigurationReader\StructArrayReservedMethod;
11
12		/**
13		* Class Struct stands for an available struct described in the WSDL
14		*/
15		class Struct extends AbstractModel
16		{
17		/**
18		* @var string
19		*/
20		const DOC_SUB_PACKAGE_STRUCTS = 'Structs';
21		/**
22		* @var string
23		*/
24		const DOC_SUB_PACKAGE_ENUMERATIONS = 'Enumerations';
25		/**
26		* @var string
27		*/
28		const DOC_SUB_PACKAGE_ARRAYS = 'Arrays';
29		/**
30		* Attributes of the struct
31		* @var StructAttributeContainer
32		*/
33		private $attributes;
34		/**
35		* Is the struct a restriction with defined values ?
36		* @var bool
37		*/
38		private $isRestriction = false;
39		/**
40		* If the struct is a restriction with values, then store values
41		* @var StructValueContainer
42		*/
43		private $values;
44		/**
45		* If the struct is a union with types, then store types
46		* @var string[]
47		*/
48		private $types;
49		/**
50		* Define if the urrent struct is a concrete struct or just a virtual struct to store meta informations
51		* @var bool
52		*/
53		private $isStruct = false;
54		/**
55		* Main constructor
56		* @see AbstractModel::__construct()
57		* @uses Struct::setStruct()
58		* @param Generator $generator
59		* @param string $name the original name
60		* @param bool $isStruct defines if it's a real sruct or not
61		* @param bool $isRestriction defines if it's an enumeration or not
62		*/
63	1190	public function __construct(Generator $generator, $name, $isStruct = true, $isRestriction = false)
64		{
65	1190	parent::__construct($generator, $name);
66	1190	$this->setStruct($isStruct)->setRestriction($isRestriction)->setAttributes(new StructAttributeContainer($generator))->setValues(new StructValueContainer($generator));
67	1190	}
68		/**
69		* Returns the contextual part of the class name for the package
70		* @see AbstractModel::getContextualPart()
71		* @uses Struct::isRestriction()
72		* @return string
73		*/
74	355	public function getContextualPart()
75		{
76	355	$part = $this->getGenerator()->getOptionStructsFolder();
77	355	if ($this->isRestriction()) {
78	135	$part = $this->getGenerator()->getOptionEnumsFolder();
79	337	} elseif ($this->isArray()) {
80	65	$part = $this->getGenerator()->getOptionArraysFolder();
81	39	}
82	355	return $part;
83		}
84		/**
85		* Returns the sub package name which the model belongs to
86		* Must be overridden by sub classes
87		* @see AbstractModel::getDocSubPackages()
88		* @uses Struct::isRestriction()
89		* @return array
90		*/
91	200	public function getDocSubPackages()
92		{
93	200	$package = self::DOC_SUB_PACKAGE_STRUCTS;
94	200	if ($this->isRestriction()) {
95	70	$package = self::DOC_SUB_PACKAGE_ENUMERATIONS;
96	184	} elseif ($this->isArray()) {
97	40	$package = self::DOC_SUB_PACKAGE_ARRAYS;
98	24	}
99		return array(
100	200	$package,
101	120	);
102		}
103		/**
104		* Returns true if the current struct is a collection of values (like an array)
105		* @uses AbstractModel::getName()
106		* @uses Struct::countOwnAttributes()
107		* @return bool
108		*/
109	395	public function isArray()
110		{
111	395	return ((($this->isStruct() && $this->countOwnAttributes() === 1) \|\| (!$this->isStruct() && $this->countOwnAttributes() <= 1)) && (stripos($this->getName(), 'array') !== false) \|\| (!$this->isStruct() && $this->getMetaValueFirstSet(array('arraytype', 'arrayType'), false) !== false));
112		}
113		/**
114		* Returns the attributes of the struct and potentially from the parent class
115		* @uses AbstractModel::getInheritance()
116		* @uses Struct::isStruct()
117		* @uses Struct::getAttributes()
118		* @param bool $includeInheritanceAttributes include the attributes of parent class, default parent attributes are not included. If true, then the array is an associative array containing and index "attribute" for the StructAttribute object and an index "model" for the Struct object.
119		* @param bool $requiredFirst places the required attributes first, then the not required in order to have the _contrust method with the required attribute at first
120		* @return StructAttributeContainer
121		*/
122	410	public function getAttributes($includeInheritanceAttributes = false, $requiredFirst = false)
123		{
124	410	if ($includeInheritanceAttributes === false && $requiredFirst === false) {
125	410	$attributes = $this->attributes;
126	246	} else {
127	155	$attributes = $this->getAllAttributes($includeInheritanceAttributes, $requiredFirst);
128		}
129	410	return $attributes;
130		}
131		/**
132		* @param bool $includeInheritanceAttributes
133		* @param bool $requiredFirst
134		* @return StructAttributeContainer
135		*/
136	155	protected function getAllAttributes($includeInheritanceAttributes, $requiredFirst)
137		{
138	155	$allAttributes = new StructAttributeContainer($this->getGenerator());
139	155	if ($includeInheritanceAttributes === true) {
140	5	$this->addInheritanceAttributes($allAttributes);
141	3	}
142	155	foreach ($this->attributes as $attribute) {
143	155	$allAttributes->add($attribute);
144	93	}
145	155	if ($requiredFirst === true) {
146	155	$attributes = $this->putRequiredFirst($allAttributes);
147	93	} else {
148		$attributes = $allAttributes;
149		}
150	155	return $attributes;
151		}
152		/**
153		* @param StructAttributeContainer $attributes
154		*/
155	5	protected function addInheritanceAttributes(StructAttributeContainer $attributes)
156		{
157	5	if ($this->getInheritance() != '' && ($model = $this->getInheritanceStruct()) instanceof Struct) {
158		while ($model instanceof Struct && $model->isStruct()) {
159		foreach ($model->getAttributes() as $attribute) {
160		$attributes->add($attribute);
161		}
162		$model = $model->getInheritanceStruct();
163		}
164		}
165	5	}
166		/**
167		* @param StructAttributeContainer $allAttributes
168		* @return StructAttributeContainer
169		*/
170	155	protected function putRequiredFirst(StructAttributeContainer $allAttributes)
171		{
172	155	$attributes = new StructAttributeContainer($this->getGenerator());
173	155	$requiredAttributes = new StructAttributeContainer($this->getGenerator());
174	155	$notRequiredAttributes = new StructAttributeContainer($this->getGenerator());
175	155	foreach ($allAttributes as $attribute) {
176	155	if ($attribute->isRequired()) {
177	40	$requiredAttributes->add($attribute);
178	24	} else {
179	149	$notRequiredAttributes->add($attribute);
180		}
181	93	}
182	155	foreach ($requiredAttributes as $attribute) {
183	40	$attributes->add($attribute);
184	93	}
185	155	foreach ($notRequiredAttributes as $attribute) {
186	145	$attributes->add($attribute);
187	93	}
188	155	unset($requiredAttributes, $notRequiredAttributes);
189	155	return $attributes;
190		}
191		/**
192		* Returns the number of own attributes
193		* @uses Struct::getAttributes()
194		* @return int
195		*/
196	395	public function countOwnAttributes()
197		{
198	395	return $this->getAttributes(false, false)->count();
199		}
200		/**
201		* Sets the attributes of the struct
202		* @param StructAttributeContainer $structAttributeContainer
203		* @return Struct
204		*/
205	1190	public function setAttributes(StructAttributeContainer $structAttributeContainer)
206		{
207	1190	$this->attributes = $structAttributeContainer;
208	1190	return $this;
209		}
210		/**
211		* Adds attribute based on its original name
212		* @throws \InvalidArgumentException
213		* @param string $attributeName the attribute name
214		* @param string $attributeType the attribute type
215		* @return Struct
216		*/
217	320	public function addAttribute($attributeName, $attributeType)
218		{
219	320	if (empty($attributeName) \|\| empty($attributeType)) {
220	10	throw new \InvalidArgumentException(sprintf('Attribute name "%s" and/or attribute type "%s" is invalid for Struct "%s"', $attributeName, $attributeType, $this->getName()), __LINE__);
221		}
222	310	if ($this->attributes->getStructAttributeByName($attributeName) === null) {
223	310	$structAttribute = new StructAttribute($this->getGenerator(), $attributeName, $attributeType, $this);
224	310	$this->attributes->add($structAttribute);
225	186	}
226	310	return $this;
227		}
228		/**
229		* Returns the attribute by its name, otherwise null
230		* @uses Struct::getAttributes()
231		* @param string $attributeName the original attribute name
232		* @return StructAttribute\|null
233		*/
234	245	public function getAttribute($attributeName)
235		{
236	245	return $this->attributes->getStructAttributeByName($attributeName);
237		}
238		/**
239		* Returns the attribute by its cleaned name, otherwise null
240		* @uses Struct::getAttributes()
241		* @param string $attributeCleanName the cleaned attribute name
242		* @return StructAttribute\|null
243		*/
244	75	public function getAttributeByCleanName($attributeCleanName)
245		{
246	75	return $this->attributes->getStructAttributeByCleanName($attributeCleanName);
247		}
248		/**
249		* Returns the isRestriction value
250		* @return bool
251		*/
252	395	public function isRestriction()
253		{
254	395	return $this->isRestriction;
255		}
256		/**
257		* Sets the isRestriction value
258		* @param bool $isRestriction
259		* @return Struct
260		*/
261	1190	public function setRestriction($isRestriction = true)
262		{
263	1190	$this->isRestriction = $isRestriction;
264	1190	return $this;
265		}
266		/**
267		* Returns the isStruct value
268		* @return bool
269		*/
270	430	public function isStruct()
271		{
272	430	return $this->isStruct;
273		}
274		/**
275		* Sets the isStruct value
276		* @param bool $isStruct
277		* @return Struct
278		*/
279	1190	public function setStruct($isStruct = true)
280		{
281	1190	$this->isStruct = $isStruct;
282	1190	return $this;
283		}
284		/**
285		* Returns the values for an enumeration
286		* @return StructValueContainer
287		*/
288	115	public function getValues()
289		{
290	115	return $this->values;
291		}
292		/**
293		* Sets the values for an enumeration
294		* @param StructValueContainer $structValueContainer
295		* @return Struct
296		*/
297	1190	protected function setValues(StructValueContainer $structValueContainer)
298		{
299	1190	$this->values = $structValueContainer;
300	1190	return $this;
301		}
302		/**
303		* Adds value to values array
304		* @uses Struct::getValue()
305		* @uses Struct::getValues()
306		* @param mixed $value the original value
307		* @return Struct
308		*/
309	80	public function addValue($value)
310		{
311	80	if ($this->getValue($value) === null) {
312	80	$this->values->add(new StructValue($this->getGenerator(), $value, $this->getValues()->count(), $this));
313	80	$this->setRestriction(true);
314	80	$this->setStruct(true);
315	48	}
316	80	return $this;
317		}
318		/**
319		* Gets the value object for the given value
320		* @uses Struct::getValues()
321		* @uses AbstractModel::getName()
322		* @param string $value Value name
323		* @return StructValue\|null
324		*/
325	115	public function getValue($value)
326		{
327	115	return $this->values->getStructValueByName($value);
328		}
329		/**
330		* Allows to define from which class the curent model extends
331		* @param bool $short
332		* @return string
333		*/
334	190	public function getExtends($short = false)
335		{
336	190	$extends = '';
337	190	if ($this->isArray()) {
338	40	$extends = $this->getGenerator()->getOptionStructArrayClass();
339	180	} elseif (!$this->isRestriction()) {
340	130	$extends = $this->getGenerator()->getOptionStructClass();
341	78	}
342	190	return $short ? Utils::removeNamespace($extends) : $extends;
343		}
344		/**
345		* @return Struct\|null
346		*/
347	270	public function getInheritanceStruct()
348		{
349	270	return $this->getGenerator()->getStruct(str_replace('[]', '', $this->getInheritance()));
350		}
351		/**
352		* @return string
353		*/
354	175	public function getTopInheritance()
355		{
356	175	$inheritance = $this->getInheritance();
357	175	if (!empty($inheritance)) {
358	80	$struct = $this->getInheritanceStruct();
359	80	while ($struct instanceof Struct) {
360	55	$structInheritance = $struct->getInheritance();
361	55	if (!empty($structInheritance)) {
362	25	$inheritance = $structInheritance;
363	15	}
364	55	$struct = $struct->getInheritanceStruct();
365	33	}
366	48	}
367	175	return $inheritance;
368		}
369		/**
370		* @see \WsdlToPhp\PackageGenerator\Model\AbstractModel::getMeta()
371		* @return string[]
372		*/
373	260	public function getMeta()
374		{
375	260	$inheritanceStruct = $this->getInheritanceStruct();
376	260	return array_merge_recursive(parent::getMeta(), ($inheritanceStruct && !$inheritanceStruct->isStruct()) ? $inheritanceStruct->getMeta() : array());
377		}
378		/**
379		* @param $filename
380		* @return StructReservedMethod\|StructArrayReservedMethod
381		*/
382	175	public function getReservedMethodsInstance($filename = null)
383		{
384	175	$instance = StructReservedMethod::instance($filename);
385	175	if ($this->isArray()) {
386	45	$instance = StructArrayReservedMethod::instance($filename);
387	27	}
388	175	return $instance;
389		}
390		/**
391		* @return string[]
392		*/
393	5	public function getTypes()
394		{
395	5	return $this->types;
396		}
397		/**
398		* @return boolean
399		*/
400	165	public function isUnion()
401		{
402	165	return count($this->types) > 0;
403		}
404		/**
405		* @param string[] $types
406		* @return Struct
407		*/
408	385	public function setTypes($types)
409		{
410	385	$this->types = $types;
411	385	return $this;
412		}
413		/**
414		* {@inheritDoc}
415		* @see \WsdlToPhp\PackageGenerator\Model\AbstractModel::toJsonSerialize()
416		*/
417	5	protected function toJsonSerialize()
418		{
419		return array(
420	5	'attributes' => $this->attributes,
421	5	'restriction' => $this->isRestriction,
422	5	'struct' => $this->isStruct,
423	5	'types' => $this->types,
424	5	'values' => $this->values,
425	3	);
426		}
427		/**
428		* @param array $attributes
429		*/
430	365	public function setAttributesFromSerializedJson(array $attributes)
431		{
432	365	foreach ($attributes as $attribute) {
433	360	$this->attributes->add(self::instanceFromSerializedJson($this->generator, $attribute)->setOwner($this));
434	219	}
435	365	}
436		/**
437		* @param array $values
438		*/
439	365	public function setValuesFromSerializedJson(array $values)
440		{
441	365	foreach ($values as $value) {
442	345	$this->values->add(self::instanceFromSerializedJson($this->generator, $value)->setOwner($this));
443	219	}
444	365	}
445		}
446

WsdlToPhp / PackageGenerator

Push — master ( 060bfa...009823 )

Struct::getValue() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like