Schema - Code Metrics - Inspection of "Merge branch 'develop' into feature/EVO-5174-exten..." - libgraviton/graviton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/EVO-5174-extending-eve... ( 070018...ce1b0c )

unknown

created 2016-07-27 08:14 UTC

Schema F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	881
Duplicated Lines	0 %

Coupling/Cohesion

Components	8
Dependencies	3

Importance

Changes	17
Bugs	2	Features	6

Metric	Value
wmc	73
c	17
b	2
f	6
lcom	8
cbo	3
dl	0
loc	881
rs	1.9672

57 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	setTitle()	4	1
A	getTitle()	4	1
A	setDescription()	4	1
A	getDescription()	4	1
C	setType()	35	8
A	getType()	4	1
A	getMinLengthTypes()	4	1
A	getFormat()	4	1
A	setFormat()	4	1
A	getNumericMinimum()	4	1
A	setNumericMinimum()	4	1
A	getNumericMaximum()	4	1
A	setNumericMaximum()	4	1
A	getMinLength()	4	1
A	setMinLength()	4	1
A	getMaxLength()	4	1
A	setMaxLength()	4	1
A	getMinItems()	4	1
A	setMinItems()	4	1
A	getMaxItems()	4	1
A	setMaxItems()	4	1
A	getEnum()	4	1
A	setEnum()	4	1
A	getRegexPattern()	4	1
A	setRegexPattern()	4	1
A	getDocumentClass()	4	1
A	setDocumentClass()	4	1
A	getConstraints()	4	1
A	setConstraints()	4	1
A	addConstraint()	4	1
A	setItems()	4	1
A	getItems()	4	1
A	addProperty()	4	1
A	removeProperty()	6	2
A	getProperty()	4	1
A	getProperties()	8	2
A	getAdditionalProperties()	4	1
A	setRequired()	5	1
A	getRequired()	9	2
A	setTranslatable()	8	2
A	isTranslatable()	9	2
A	setRefCollection()	4	1
A	getRefCollection()	9	2
A	setEventNames()	4	1
A	getEventNames()	9	2
A	setReadOnly()	4	1
A	getReadOnly()	4	2
A	isRecordOriginModifiable()	4	1
A	setRecordOriginModifiable()	4	1
A	isRecordOriginException()	4	1
A	setRecordOriginException()	4	1
A	setSearchable()	4	1
A	getSearchable()	7	2
A	getTextIndexes()	4	1
A	setTextIndexes()	4	1
A	setAdditionalProperties()	4	1

How to fix Complexity

<?php
/**
 * Graviton Schema Document
 */

namespace Graviton\SchemaBundle\Document;

use \Doctrine\Common\Collections\ArrayCollection;

/**
 * Graviton\SchemaBundle\Document\Schema
 *
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class Schema
{
    /**
     * @var string
     */
    protected $title;

    /**
     * @var string
     */
    protected $description;

    /**
     * @var SchemaType
     */
    protected $type;

    /**
     * @var string
     */
    protected $format;

    /**
     * @var Schema
     */
    protected $items;

    /**
     * @var ArrayCollection
     */
    protected $properties;

    /**
     * @var SchemaAdditionalProperties
     */
    protected $additionalProperties;

    /**
     * @var string[]
     */
    protected $required = [];

    /**
     * @var boolean
     */
    protected $translatable;

    /**
     * @var array
     */
    protected $refCollection = [];

    /**
     * possible event names this collection implements (queue events)
     *
     * @var array
     */
    protected $eventNames = [];

    /**
     * @var bool
     */
    protected $readOnly = false;

    /**
     * @var bool
     */
    protected $recordOriginModifiable;

    /**
     * @var bool
     */
    protected $recordOriginException;

    /**
     * @var string[]
     */
    protected $searchable = [];

    /**
     * @var int
     */
    protected $minLength;

    /**
     * @var int
     */
    protected $maxLength;

    /**
     * @var int
     */
    protected $minItems;

    /**
     * @var int
     */
    protected $maxItems;

    /**
     * @var float
     */
    protected $numericMinimum;

    /**
     * @var float
     */
    protected $numericMaximum;

    /**
     * @var SchemaEnum
     */
    protected $enum;

    /**
     * @var string
     */
    protected $regexPattern;

    /**
     * @var string
     */
    protected $documentClass;

    /**
     * @var array<string>
     */
    protected $constraints;

    /**
     * @var array<string>
     */
    protected $textIndexes;

    /**
     * these are the BSON primitive types.
     * http://json-schema.org/latest/json-schema-core.html#anchor8
     * every type set *not* in this set will be carried over to 'format'
     *
     * @var string[]
     */
    protected $primitiveTypes = [
        'array',
        'boolean',
        'integer',
        'number',
        'null',
        'object',
        'string'
    ];

    /**
     * those are types that when they are required, a minimal length
     * shall be specified in schema (or allow null if not required; that will lead
     * to the inclusion of "null" in the "type" property array)
     *
     * @var array
     */
    protected $minLengthTypes = [
        'integer',
        'number',
        'float',
        'double',
        'decimal',
        'string',
        'date',
        'extref'
    ];

    /**
     * known non-primitive types we map to primitives here.
     * the type itself is set to the format.
     *
     * @var string[]
     */
    protected $specialTypeMapping = [
        'extref' => 'string',
        'translatable' => 'object',
        'date' => 'string',
        'float' => 'number',
        'double' => 'number',
        'decimal' => 'number'
    ];

    protected $formatOverrides = [
        'date' => 'date-time'
    ];

    /**
     * Build properties
     */
    public function __construct()
    {
        $this->properties = new ArrayCollection();
    }

    /**
     * set title
     *
     * @param string $title title
     *
     * @return void
     */
    public function setTitle($title)
    {
        $this->title = $title;
    }

    /**
     * get title
     *
     * @return string
     */
    public function getTitle()
    {
        return $this->title;
    }

    /**
     * set description
     *
     * @param string $description description
     *
     * @return void
     */
    public function setDescription($description)
    {
        $this->description = $description;
    }

    /**
     * get description
     *
     * @return string
     */
    public function getDescription()
    {
        return $this->description;
    }

    /**
     * set type
     *
     * @param string|array $types types
     *
     * @return void
     */
    public function setType($types)
    {
        if (!is_array($types)) {
            $types = [$types];
        }

        $typesToSet = [];
        foreach ($types as $type) {
            if ($type === 'int') {
                $type = 'integer';
            }
            if ($type === 'hash') {
                $type = 'object';
            }

            // handle non-primitive types
            if (!in_array($type, $this->primitiveTypes)) {
                $setType = 'string';
                if (isset($this->specialTypeMapping[$type])) {
                    $setType = $this->specialTypeMapping[$type];
                }
                $typesToSet[] = $setType;

                if (isset($this->formatOverrides[$type])) {
                    $type = $this->formatOverrides[$type];
                }

                $this->setFormat($type);
            } else {
                $typesToSet[] = $type;
            }
        }

        $this->type = new SchemaType($typesToSet);
    }

    /**
     * get type
     *
     * @return SchemaType type
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * get MinLengthTypes
     *
     * @return array MinLengthTypes
     */
    public function getMinLengthTypes()
    {
        return $this->minLengthTypes;
    }

    /**
     * get format
     *
     * @return string format
     */
    public function getFormat()
    {
        return $this->format;
    }

    /**
     * sets format
     *
     * @param string $format format
     *
     * @return void
     */
    public function setFormat($format)
    {
        $this->format = $format;
    }

    /**
     * get numeric minimum
     *
     * @return float numeric minimum
     */
    public function getNumericMinimum()
    {
        return $this->numericMinimum;
    }

    /**
     * set numeric minimum
     *
     * @param float $numericMinimum numeric mimimum
     *
     * @return void
     */
    public function setNumericMinimum($numericMinimum)
    {
        $this->numericMinimum = $numericMinimum;
    }

    /**
     * get numeric maximum
     *
     * @return float numeric maximum
     */
    public function getNumericMaximum()
    {
        return $this->numericMaximum;
    }

    /**
     * set numeric maximum
     *
     * @param float $numericMaximum maximum
     *
     * @return void
     */
    public function setNumericMaximum($numericMaximum)
    {
        $this->numericMaximum = $numericMaximum;
    }

    /**
     * set min length
     *
     * @return int length
     */
    public function getMinLength()
    {
        return $this->minLength;
    }

    /**
     * get min length
     *
     * @param int $minLength length
     *
     * @return void
     */
    public function setMinLength($minLength)
    {
        $this->minLength = $minLength;
    }

    /**
     * gets maxlength
     *
     * @return int length
     */
    public function getMaxLength()
    {
        return $this->maxLength;
    }

    /**
     * set maxlength
     *
     * @param int $maxLength length
     *
     * @return void
     */
    public function setMaxLength($maxLength)
    {
        $this->maxLength = $maxLength;
    }

    /**
     * set min Items
     *
     * @return int Items
     */
    public function getMinItems()
    {
        return $this->minItems;
    }

    /**
     * get min Items
     *
     * @param int $minItems length
     *
     * @return void
     */
    public function setMinItems($minItems)
    {
        $this->minItems = $minItems;
    }

    /**
     * gets maxItems
     *
     * @return int Items
     */
    public function getMaxItems()
    {
        return $this->maxItems;
    }

    /**
     * set maxItems
     *
     * @param int $maxItems Items
     *
     * @return void
     */
    public function setMaxItems($maxItems)
    {
        $this->maxItems = $maxItems;
    }

    /**
     * get Enum
     *
     * @return array Enum

     */
    public function getEnum()
    {
        return $this->enum;
    }

    /**
     * set Enum
     *
     * @param array $enum enum
     *
     * @return void
     */
    public function setEnum(array $enum)
    {
        $this->enum = new SchemaEnum($enum);
    }

    /**
     * get regex pattern
     *
     * @return string pattern
     */
    public function getRegexPattern()
    {
        return $this->regexPattern;
    }

    /**
     * set regex pattern
     *
     * @param string $regexPattern regex pattern
     *
     * @return void
     */
    public function setRegexPattern($regexPattern)
    {
        $this->regexPattern = $regexPattern;
    }

    /**
     * get DocumentClass
     *
     * @return string DocumentClass
     */
    public function getDocumentClass()
    {
        return $this->documentClass;
    }

    /**
     * set DocumentClass
     *
     * @param string $documentClass documentClass
     *
     * @return void
     */
    public function setDocumentClass($documentClass)
    {
        $this->documentClass = $documentClass;
    }

    /**
     * get Constraints
     *
     * @return mixed Constraints

     */
    public function getConstraints()
    {
        return $this->constraints;
    }

    /**
     * set Constraints
     *
     * @param mixed $constraints constraints
     *
     * @return void
     */
    public function setConstraints($constraints)
    {
        $this->constraints = $constraints;

    }

    /**
     * add a constraint
     *
     * @param string $name constraint name
     *
     * @return void
     */
    public function addConstraint($name)
    {
        $this->constraints[] = $name;
    }

    /**
     * set items
     *
     * @param Schema $items items schema
     *
     * @return void
     */
    public function setItems($items)
    {
        $this->items = $items;
    }

    /**
     * get items
     *
     * @return Schema
     */
    public function getItems()
    {
        return $this->items;
    }

    /**
     * add a property
     *
     * @param string $name     property name
     * @param Schema $property property
     *
     * @return void
     */
    public function addProperty($name, $property)
    {
        $this->properties->set($name, $property);
    }

    /**
     * removes a property
     *
     * @param string $name property name
     *
     * @return void
     */
    public function removeProperty($name)
    {
        if (!$this->properties->containsKey($name)) {
            $this->properties->remove($this->properties->get($name));
        }
    }

    /**
     * returns a property
     *
     * @param string $name property name
     *
     * @return void|Schema property
     */
    public function getProperty($name)
    {
        return $this->properties->get($name);
    }

    /**
     * get properties
     *
     * @return ArrayCollection|null
     */
    public function getProperties()
    {
        if ($this->properties->isEmpty()) {
            return null;
        } else {
            return $this->properties;
        }
    }

    /**
     * set additionalProperties on schema
     *
     * @param SchemaAdditionalProperties $additionalProperties additional properties
     *
     * @return void
     */
    public function setAdditionalProperties(SchemaAdditionalProperties $additionalProperties)
    {
        $this->additionalProperties = $additionalProperties;
    }

    /**
     * get addtionalProperties for schema
     *
     * @return SchemaAdditionalProperties
     */
    public function getAdditionalProperties()
    {
        return $this->additionalProperties;
    }

    /**
     * set required variables
     *
     * @param string[] $required array of required fields
     *
     * @return void
     */
    public function setRequired(array $required)
    {
        // needed as indexes could we off and we want to enforce an array after json_encode
        $this->required = array_values($required);
    }

    /**
     * get required fields
     *
     * @return string[]|null
     */
    public function getRequired()
    {
        $required = $this->required;
        if (empty($required)) {
            $required = null;
        }

        return $required;
    }

    /**
     * set translatable flag
     *
     * This flag is a local extension to json schema.
     *
     * @param boolean $translatable translatable flag
     *
     * @return void
     */
    public function setTranslatable($translatable)
    {
        if ($translatable === true) {
            $this->setType('translatable');
        } else {
            $this->setType('string');
        }
    }

    /**
     * get translatable flag
     *
     * @return boolean
     */
    public function isTranslatable()
    {
        $ret = false;
        if ($this->getFormat() == 'translatable') {
            $ret = true;
        }

        return $ret;
    }

    /**
     * set a array of urls that can extref refer to
     *
     * @param array $refCollection urls
     *
     * @return void
     */
    public function setRefCollection(array $refCollection)
    {
        $this->refCollection = $refCollection;
    }

    /**
     * get a collection of urls that can extref refer to
     *
     * @return array

     */
    public function getRefCollection()
    {
        $collection = $this->refCollection;
        if (empty($collection)) {
            $collection = null;
        }

        return $collection;
    }

    /**
     * set an array of possible event names
     *
     * @param array $eventNames event names
     *
     * @return void
     */
    public function setEventNames(array $eventNames)
    {
        $this->eventNames = array_values($eventNames);
    }

    /**
     * get a collection of possible event names
     *
     * @return array

     */
    public function getEventNames()
    {
        $collection = $this->eventNames;
        if (empty($collection)) {
            $collection = null;
        }

        return $collection;
    }

    /**
     * Set the readOnly flag
     *
     * @param bool $readOnly ReadOnly flag
     *
     * @return void
     */
    public function setReadOnly($readOnly)
    {
        $this->readOnly = (bool) $readOnly;
    }

    /**
     * Get the readOnly flag.
     * Returns null if the flag is set to false so the serializer will ignore it.
     *
     * @return bool|null true if readOnly isset to true or null if not
     */
    public function getReadOnly()
    {
        return $this->readOnly ? true : null;
    }

    /**
     * get RecordOriginModifiable
     *
     * @return boolean RecordOriginModifiable
     */
    public function isRecordOriginModifiable()
    {
        return $this->recordOriginModifiable;
    }

    /**
     * set RecordOriginModifiable
     *
     * @param boolean $recordOriginModifiable recordOriginModifiable
     *
     * @return void
     */
    public function setRecordOriginModifiable($recordOriginModifiable)
    {
        $this->recordOriginModifiable = $recordOriginModifiable;
    }

    /**
     * get RecordOriginException
     *
     * @return boolean RecordOriginException
     */
    public function isRecordOriginException()
    {
        return $this->recordOriginException;
    }

    /**
     * set RecordOriginException
     *
     * @param boolean $recordOriginException recordOriginException
     *
     * @return void
     */
    public function setRecordOriginException($recordOriginException)
    {
        $this->recordOriginException = $recordOriginException;
    }

    /**
     * set searchable variables
     *
     * @param string[] $searchable array of searchable fields
     *
     * @return void
     */
    public function setSearchable($searchable)
    {
        $this->searchable = $searchable;
    }

    /**
     * get searchable fields
     *
     * @return string[]|null
     */
    public function getSearchable()
    {
        if (empty($this->searchable)) {
            return null;
        }
        return $this->searchable;
    }

    /**
     * @return array

     */
    public function getTextIndexes()
    {
        return $this->textIndexes;
    }

    /**
     * get textIndexes fields
     *
     * @param array $textIndexes Data array of special text search values
     *
     * @return void
     */
    public function setTextIndexes($textIndexes)
    {
        $this->textIndexes = $textIndexes;
    }
}


1			<?php
2			/**
3			* Graviton Schema Document
4			*/
5
6			namespace Graviton\SchemaBundle\Document;
7
8			use \Doctrine\Common\Collections\ArrayCollection;
9
10			/**
11			* Graviton\SchemaBundle\Document\Schema
12			*
13			* @author List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
14			* @license http://opensource.org/licenses/gpl-license.php GNU Public License
15			* @link http://swisscom.ch
16			*/
17			class Schema
18			{
19			/**
20			* @var string
21			*/
22			protected $title;
23
24			/**
25			* @var string
26			*/
27			protected $description;
28
29			/**
30			* @var SchemaType
31			*/
32			protected $type;
33
34			/**
35			* @var string
36			*/
37			protected $format;
38
39			/**
40			* @var Schema
41			*/
42			protected $items;
43
44			/**
45			* @var ArrayCollection
46			*/
47			protected $properties;
48
49			/**
50			* @var SchemaAdditionalProperties
51			*/
52			protected $additionalProperties;
53
54			/**
55			* @var string[]
56			*/
57			protected $required = [];
58
59			/**
60			* @var boolean
61			*/
62			protected $translatable;
63
64			/**
65			* @var array
66			*/
67			protected $refCollection = [];
68
69			/**
70			* possible event names this collection implements (queue events)
71			*
72			* @var array
73			*/
74			protected $eventNames = [];
75
76			/**
77			* @var bool
78			*/
79			protected $readOnly = false;
80
81			/**
82			* @var bool
83			*/
84			protected $recordOriginModifiable;
85
86			/**
87			* @var bool
88			*/
89			protected $recordOriginException;
90
91			/**
92			* @var string[]
93			*/
94			protected $searchable = [];
95
96			/**
97			* @var int
98			*/
99			protected $minLength;
100
101			/**
102			* @var int
103			*/
104			protected $maxLength;
105
106			/**
107			* @var int
108			*/
109			protected $minItems;
110
111			/**
112			* @var int
113			*/
114			protected $maxItems;
115
116			/**
117			* @var float
118			*/
119			protected $numericMinimum;
120
121			/**
122			* @var float
123			*/
124			protected $numericMaximum;
125
126			/**
127			* @var SchemaEnum
128			*/
129			protected $enum;
130
131			/**
132			* @var string
133			*/
134			protected $regexPattern;
135
136			/**
137			* @var string
138			*/
139			protected $documentClass;
140
141			/**
142			* @var array<string>
143			*/
144			protected $constraints;
145
146			/**
147			* @var array<string>
148			*/
149			protected $textIndexes;
150
151			/**
152			* these are the BSON primitive types.
153			* http://json-schema.org/latest/json-schema-core.html#anchor8
154			* every type set not in this set will be carried over to 'format'
155			*
156			* @var string[]
157			*/
158			protected $primitiveTypes = [
159			'array',
160			'boolean',
161			'integer',
162			'number',
163			'null',
164			'object',
165			'string'
166			];
167
168			/**
169			* those are types that when they are required, a minimal length
170			* shall be specified in schema (or allow null if not required; that will lead
171			* to the inclusion of "null" in the "type" property array)
172			*
173			* @var array
174			*/
175			protected $minLengthTypes = [
176			'integer',
177			'number',
178			'float',
179			'double',
180			'decimal',
181			'string',
182			'date',
183			'extref'
184			];
185
186			/**
187			* known non-primitive types we map to primitives here.
188			* the type itself is set to the format.
189			*
190			* @var string[]
191			*/
192			protected $specialTypeMapping = [
193			'extref' => 'string',
194			'translatable' => 'object',
195			'date' => 'string',
196			'float' => 'number',
197			'double' => 'number',
198			'decimal' => 'number'
199			];
200
201			protected $formatOverrides = [
202			'date' => 'date-time'
203			];
204
205			/**
206			* Build properties
207			*/
208			public function __construct()
209			{
210			$this->properties = new ArrayCollection();
211			}
212
213			/**
214			* set title
215			*
216			* @param string $title title
217			*
218			* @return void
219			*/
220			public function setTitle($title)
221			{
222			$this->title = $title;
223			}
224
225			/**
226			* get title
227			*
228			* @return string
229			*/
230			public function getTitle()
231			{
232			return $this->title;
233			}
234
235			/**
236			* set description
237			*
238			* @param string $description description
239			*
240			* @return void
241			*/
242			public function setDescription($description)
243			{
244			$this->description = $description;
245			}
246
247			/**
248			* get description
249			*
250			* @return string
251			*/
252			public function getDescription()
253			{
254			return $this->description;
255			}
256
257			/**
258			* set type
259			*
260			* @param string\|array $types types
261			*
262			* @return void
263			*/
264			public function setType($types)
265			{
266			if (!is_array($types)) {
267			$types = [$types];
268			}
269
270			$typesToSet = [];
271			foreach ($types as $type) {
272			if ($type === 'int') {
273			$type = 'integer';
274			}
275			if ($type === 'hash') {
276			$type = 'object';
277			}
278
279			// handle non-primitive types
280			if (!in_array($type, $this->primitiveTypes)) {
281			$setType = 'string';
282			if (isset($this->specialTypeMapping[$type])) {
283			$setType = $this->specialTypeMapping[$type];
284			}
285			$typesToSet[] = $setType;
286
287			if (isset($this->formatOverrides[$type])) {
288			$type = $this->formatOverrides[$type];
289			}
290
291			$this->setFormat($type);
292			} else {
293			$typesToSet[] = $type;
294			}
295			}
296
297			$this->type = new SchemaType($typesToSet);
298			}
299
300			/**
301			* get type
302			*
303			* @return SchemaType type
304			*/
305			public function getType()
306			{
307			return $this->type;
308			}
309
310			/**
311			* get MinLengthTypes
312			*
313			* @return array MinLengthTypes
314			*/
315			public function getMinLengthTypes()
316			{
317			return $this->minLengthTypes;
318			}
319
320			/**
321			* get format
322			*
323			* @return string format
324			*/
325			public function getFormat()
326			{
327			return $this->format;
328			}
329
330			/**
331			* sets format
332			*
333			* @param string $format format
334			*
335			* @return void
336			*/
337			public function setFormat($format)
338			{
339			$this->format = $format;
340			}
341
342			/**
343			* get numeric minimum
344			*
345			* @return float numeric minimum
346			*/
347			public function getNumericMinimum()
348			{
349			return $this->numericMinimum;
350			}
351
352			/**
353			* set numeric minimum
354			*
355			* @param float $numericMinimum numeric mimimum
356			*
357			* @return void
358			*/
359			public function setNumericMinimum($numericMinimum)
360			{
361			$this->numericMinimum = $numericMinimum;
362			}
363
364			/**
365			* get numeric maximum
366			*
367			* @return float numeric maximum
368			*/
369			public function getNumericMaximum()
370			{
371			return $this->numericMaximum;
372			}
373
374			/**
375			* set numeric maximum
376			*
377			* @param float $numericMaximum maximum
378			*
379			* @return void
380			*/
381			public function setNumericMaximum($numericMaximum)
382			{
383			$this->numericMaximum = $numericMaximum;
384			}
385
386			/**
387			* set min length
388			*
389			* @return int length
390			*/
391			public function getMinLength()
392			{
393			return $this->minLength;
394			}
395
396			/**
397			* get min length
398			*
399			* @param int $minLength length
400			*
401			* @return void
402			*/
403			public function setMinLength($minLength)
404			{
405			$this->minLength = $minLength;
406			}
407
408			/**
409			* gets maxlength
410			*
411			* @return int length
412			*/
413			public function getMaxLength()
414			{
415			return $this->maxLength;
416			}
417
418			/**
419			* set maxlength
420			*
421			* @param int $maxLength length
422			*
423			* @return void
424			*/
425			public function setMaxLength($maxLength)
426			{
427			$this->maxLength = $maxLength;
428			}
429
430			/**
431			* set min Items
432			*
433			* @return int Items
434			*/
435			public function getMinItems()
436			{
437			return $this->minItems;
438			}
439
440			/**
441			* get min Items
442			*
443			* @param int $minItems length
444			*
445			* @return void
446			*/
447			public function setMinItems($minItems)
448			{
449			$this->minItems = $minItems;
450			}
451
452			/**
453			* gets maxItems
454			*
455			* @return int Items
456			*/
457			public function getMaxItems()
458			{
459			return $this->maxItems;
460			}
461
462			/**
463			* set maxItems
464			*
465			* @param int $maxItems Items
466			*
467			* @return void
468			*/
469			public function setMaxItems($maxItems)
470			{
471			$this->maxItems = $maxItems;
472			}
473
474			/**
475			* get Enum
476			*
477			* @return array Enum
			0 ignored issues – show Documentation introduced 2016-06-13 11:15 UTC by Report Bug Copy Issue Report Should the return type not be `SchemaEnum`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
478			*/
479			public function getEnum()
480			{
481			return $this->enum;
482			}
483
484			/**
485			* set Enum
486			*
487			* @param array $enum enum
488			*
489			* @return void
490			*/
491			public function setEnum(array $enum)
492			{
493			$this->enum = new SchemaEnum($enum);
494			}
495
496			/**
497			* get regex pattern
498			*
499			* @return string pattern
500			*/
501			public function getRegexPattern()
502			{
503			return $this->regexPattern;
504			}
505
506			/**
507			* set regex pattern
508			*
509			* @param string $regexPattern regex pattern
510			*
511			* @return void
512			*/
513			public function setRegexPattern($regexPattern)
514			{
515			$this->regexPattern = $regexPattern;
516			}
517
518			/**
519			* get DocumentClass
520			*
521			* @return string DocumentClass
522			*/
523			public function getDocumentClass()
524			{
525			return $this->documentClass;
526			}
527
528			/**
529			* set DocumentClass
530			*
531			* @param string $documentClass documentClass
532			*
533			* @return void
534			*/
535			public function setDocumentClass($documentClass)
536			{
537			$this->documentClass = $documentClass;
538			}
539
540			/**
541			* get Constraints
542			*
543			* @return mixed Constraints
			0 ignored issues – show Documentation introduced 2016-07-06 12:15 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `string[]`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
544			*/
545			public function getConstraints()
546			{
547			return $this->constraints;
548			}
549
550			/**
551			* set Constraints
552			*
553			* @param mixed $constraints constraints
554			*
555			* @return void
556			*/
557			public function setConstraints($constraints)
558			{
559			$this->constraints = $constraints;
			0 ignored issues – show Documentation Bug introduced 2016-07-06 12:15 UTC by Report Bug Copy Issue Report It seems like `$constraints` of type `*` is incompatible with the declared type `array<integer,string>` of property `$constraints`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
560			}
561
562			/**
563			* add a constraint
564			*
565			* @param string $name constraint name
566			*
567			* @return void
568			*/
569			public function addConstraint($name)
570			{
571			$this->constraints[] = $name;
572			}
573
574			/**
575			* set items
576			*
577			* @param Schema $items items schema
578			*
579			* @return void
580			*/
581			public function setItems($items)
582			{
583			$this->items = $items;
584			}
585
586			/**
587			* get items
588			*
589			* @return Schema
590			*/
591			public function getItems()
592			{
593			return $this->items;
594			}
595
596			/**
597			* add a property
598			*
599			* @param string $name property name
600			* @param Schema $property property
601			*
602			* @return void
603			*/
604			public function addProperty($name, $property)
605			{
606			$this->properties->set($name, $property);
607			}
608
609			/**
610			* removes a property
611			*
612			* @param string $name property name
613			*
614			* @return void
615			*/
616			public function removeProperty($name)
617			{
618			if (!$this->properties->containsKey($name)) {
619			$this->properties->remove($this->properties->get($name));
620			}
621			}
622
623			/**
624			* returns a property
625			*
626			* @param string $name property name
627			*
628			* @return void\|Schema property
629			*/
630			public function getProperty($name)
631			{
632			return $this->properties->get($name);
633			}
634
635			/**
636			* get properties
637			*
638			* @return ArrayCollection\|null
639			*/
640			public function getProperties()
641			{
642			if ($this->properties->isEmpty()) {
643			return null;
644			} else {
645			return $this->properties;
646			}
647			}
648
649			/**
650			* set additionalProperties on schema
651			*
652			* @param SchemaAdditionalProperties $additionalProperties additional properties
653			*
654			* @return void
655			*/
656			public function setAdditionalProperties(SchemaAdditionalProperties $additionalProperties)
657			{
658			$this->additionalProperties = $additionalProperties;
659			}
660
661			/**
662			* get addtionalProperties for schema
663			*
664			* @return SchemaAdditionalProperties
665			*/
666			public function getAdditionalProperties()
667			{
668			return $this->additionalProperties;
669			}
670
671			/**
672			* set required variables
673			*
674			* @param string[] $required array of required fields
675			*
676			* @return void
677			*/
678			public function setRequired(array $required)
679			{
680			// needed as indexes could we off and we want to enforce an array after json_encode
681			$this->required = array_values($required);
682			}
683
684			/**
685			* get required fields
686			*
687			* @return string[]\|null
688			*/
689			public function getRequired()
690			{
691			$required = $this->required;
692			if (empty($required)) {
693			$required = null;
694			}
695
696			return $required;
697			}
698
699			/**
700			* set translatable flag
701			*
702			* This flag is a local extension to json schema.
703			*
704			* @param boolean $translatable translatable flag
705			*
706			* @return void
707			*/
708			public function setTranslatable($translatable)
709			{
710			if ($translatable === true) {
711			$this->setType('translatable');
712			} else {
713			$this->setType('string');
714			}
715			}
716
717			/**
718			* get translatable flag
719			*
720			* @return boolean
721			*/
722			public function isTranslatable()
723			{
724			$ret = false;
725			if ($this->getFormat() == 'translatable') {
726			$ret = true;
727			}
728
729			return $ret;
730			}
731
732			/**
733			* set a array of urls that can extref refer to
734			*
735			* @param array $refCollection urls
736			*
737			* @return void
738			*/
739			public function setRefCollection(array $refCollection)
740			{
741			$this->refCollection = $refCollection;
742			}
743
744			/**
745			* get a collection of urls that can extref refer to
746			*
747			* @return array
			0 ignored issues – show Documentation introduced 2016-04-01 10:11 UTC by Report Bug Copy Issue Report Should the return type not be `null\|array`? Also, consider making the array more specific, something like `array<String>`, or `String[]`. This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. If the return type contains the type array, this check recommends the use of a more specific type like `String[]` or `array<String>`. Loading history...
748			*/
749			public function getRefCollection()
750			{
751			$collection = $this->refCollection;
752			if (empty($collection)) {
753			$collection = null;
754			}
755
756			return $collection;
757			}
758
759			/**
760			* set an array of possible event names
761			*
762			* @param array $eventNames event names
763			*
764			* @return void
765			*/
766			public function setEventNames(array $eventNames)
767			{
768			$this->eventNames = array_values($eventNames);
769			}
770
771			/**
772			* get a collection of possible event names
773			*
774			* @return array
			0 ignored issues – show Documentation introduced 2016-06-13 11:15 UTC by Report Bug Copy Issue Report Should the return type not be `null\|array`? Also, consider making the array more specific, something like `array<String>`, or `String[]`. This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. If the return type contains the type array, this check recommends the use of a more specific type like `String[]` or `array<String>`. Loading history...
775			*/
776			public function getEventNames()
777			{
778			$collection = $this->eventNames;
779			if (empty($collection)) {
780			$collection = null;
781			}
782
783			return $collection;
784			}
785
786			/**
787			* Set the readOnly flag
788			*
789			* @param bool $readOnly ReadOnly flag
790			*
791			* @return void
792			*/
793			public function setReadOnly($readOnly)
794			{
795			$this->readOnly = (bool) $readOnly;
796			}
797
798			/**
799			* Get the readOnly flag.
800			* Returns null if the flag is set to false so the serializer will ignore it.
801			*
802			* @return bool\|null true if readOnly isset to true or null if not
803			*/
804			public function getReadOnly()
805			{
806			return $this->readOnly ? true : null;
807			}
808
809			/**
810			* get RecordOriginModifiable
811			*
812			* @return boolean RecordOriginModifiable
813			*/
814			public function isRecordOriginModifiable()
815			{
816			return $this->recordOriginModifiable;
817			}
818
819			/**
820			* set RecordOriginModifiable
821			*
822			* @param boolean $recordOriginModifiable recordOriginModifiable
823			*
824			* @return void
825			*/
826			public function setRecordOriginModifiable($recordOriginModifiable)
827			{
828			$this->recordOriginModifiable = $recordOriginModifiable;
829			}
830
831			/**
832			* get RecordOriginException
833			*
834			* @return boolean RecordOriginException
835			*/
836			public function isRecordOriginException()
837			{
838			return $this->recordOriginException;
839			}
840
841			/**
842			* set RecordOriginException
843			*
844			* @param boolean $recordOriginException recordOriginException
845			*
846			* @return void
847			*/
848			public function setRecordOriginException($recordOriginException)
849			{
850			$this->recordOriginException = $recordOriginException;
851			}
852
853			/**
854			* set searchable variables
855			*
856			* @param string[] $searchable array of searchable fields
857			*
858			* @return void
859			*/
860			public function setSearchable($searchable)
861			{
862			$this->searchable = $searchable;
863			}
864
865			/**
866			* get searchable fields
867			*
868			* @return string[]\|null
869			*/
870			public function getSearchable()
871			{
872			if (empty($this->searchable)) {
873			return null;
874			}
875			return $this->searchable;
876			}
877
878			/**
879			* @return array
			0 ignored issues – show Documentation introduced 2016-07-26 15:28 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `string[]`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
880			*/
881			public function getTextIndexes()
882			{
883			return $this->textIndexes;
884			}
885
886			/**
887			* get textIndexes fields
888			*
889			* @param array $textIndexes Data array of special text search values
890			*
891			* @return void
892			*/
893			public function setTextIndexes($textIndexes)
894			{
895			$this->textIndexes = $textIndexes;
896			}
897			}
898

libgraviton / graviton

Push — feature/EVO-5174-extending-eve... ( 070018...ce1b0c )

Schema F

Complexity

Size/Duplication

Coupling/Cohesion

Importance

57 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like