Matcher - Code Metrics - Inspection of "[TASK] Use QueryBuilder in PageFacet" - fabarea/vidi - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3efc81...a16fdb )

by Fabien

created 2019-05-02 08:33 UTC

Matcher A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	498
Duplicated Lines	0 %

Coupling/Cohesion

Components	8
Dependencies	0

Importance

Changes

Metric	Value
wmc	41
lcom	8
cbo	0
dl	0
loc	498
rs	9.1199
c	0
b	0
f	0

40 Methods

Rating	Name	Size	Complexity
A	__construct()	5	1
A	setSearchTerm()	5	1
A	getSearchTerm()	4	1
A	getEquals()	4	1
A	equals()	5	1
A	getNotEquals()	4	1
A	notEquals()	5	1
A	getGreaterThan()	4	1
A	greaterThan()	5	1
A	getGreaterThanOrEqual()	4	1
A	greaterThanOrEqual()	5	1
A	getLessThan()	4	1
A	lessThan()	5	1
A	getLessThanOrEqual()	4	1
A	lessThanOrEqual()	5	1
A	getLike()	4	1
A	in()	5	1
A	getIn()	4	1
A	like()	6	2
A	getDefaultLogicalSeparator()	4	1
A	setDefaultLogicalSeparator()	5	1
A	getLogicalSeparatorForEquals()	4	1
A	setLogicalSeparatorForEquals()	5	1
A	getLogicalSeparatorForGreaterThan()	4	1
A	setLogicalSeparatorForGreaterThan()	5	1
A	getLogicalSeparatorForGreaterThanOrEqual()	4	1
A	setLogicalSeparatorForGreaterThanOrEqual()	5	1
A	getLogicalSeparatorForLessThan()	4	1
A	setLogicalSeparatorForLessThan()	5	1
A	getLogicalSeparatorForLessThanOrEqual()	4	1
A	setLogicalSeparatorForLessThanOrEqual()	5	1
A	getLogicalSeparatorForIn()	4	1
A	setLogicalSeparatorForIn()	5	1
A	getLogicalSeparatorForLike()	4	1
A	setLogicalSeparatorForLike()	5	1
A	getLogicalSeparatorForSearchTerm()	4	1
A	setLogicalSeparatorForSearchTerm()	5	1
A	getSupportedOperators()	4	1
A	getDataType()	4	1
A	setDataType()	5	1

How to fix Complexity

<?php
namespace Fab\Vidi\Persistence;

/*
 * This file is part of the Fab/Vidi project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

/**
 * Matcher class for conditions that will apply to a query.
 */
class Matcher
{
    /**
     * The logical OR
     */
    const LOGICAL_OR = 'logicalOr';

    /**
     * The logical AND
     */
    const LOGICAL_AND = 'logicalAnd';

    /**
     * @var string
     */
    protected $dataType = '';

    /**
     * @var string
     */
    protected $searchTerm = '';

    /**
     * @var array
     */
    protected $supportedOperators = [
        '=' => 'equals',
        '!=' => 'notEquals',
        'in' => 'in',
        'like' => 'like',
        '>' => 'greaterThan',
        '>=' => 'greaterThanOrEqual',
        '<' => 'lessThan',
        '<=' => 'lessThanOrEqual',
    ];

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

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

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

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

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

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

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

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

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

    /**
     * @var string
     */
    protected $defaultLogicalSeparator = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForEquals = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForGreaterThan = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForGreaterThanOrEqual = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForLessThan = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForLessThanOrEqual = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForIn = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForLike = self::LOGICAL_AND;

    /**
     * @var string
     */
    protected $logicalSeparatorForSearchTerm = self::LOGICAL_OR;

    /**
     * Constructs a new Matcher
     *
     * @param array $matches associative [$field => $value]
     * @param string $dataType which corresponds to an entry of the TCA (table name).
     */
    public function __construct($matches = [], $dataType = '')
    {
        $this->dataType = $dataType;
        $this->matches = $matches;
    }

    /**
     * @param string $searchTerm
     * @return \Fab\Vidi\Persistence\Matcher
     */
    public function setSearchTerm($searchTerm): Matcher
    {
        $this->searchTerm = $searchTerm;
        return $this;
    }

    /**
     * @return string
     */
    public function getSearchTerm(): string
    {
        return $this->searchTerm;
    }

    /**
     * @return array
     */
    public function getEquals(): array
    {
        return $this->equals;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @return $this
     */
    public function equals($fieldNameAndPath, $operand): self
    {
        $this->equals[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
        return $this;
    }

    /**
     * @return array
     */
    public function getNotEquals(): array
    {
        return $this->notEquals;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @return $this
     */
    public function notEquals($fieldNameAndPath, $operand): self
    {
        $this->notEquals[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
        return $this;
    }

    /**
     * @return array
     */
    public function getGreaterThan(): array
    {
        return $this->greaterThan;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @return $this
     */
    public function greaterThan($fieldNameAndPath, $operand): self
    {
        $this->greaterThan[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
        return $this;
    }

    /**
     * @return array
     */
    public function getGreaterThanOrEqual(): array
    {
        return $this->greaterThanOrEqual;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @return $this
     */
    public function greaterThanOrEqual($fieldNameAndPath, $operand): self
    {
        $this->greaterThanOrEqual[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
        return $this;
    }

    /**
     * @return array
     */
    public function getLessThan(): array
    {
        return $this->lessThan;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @return $this
     */
    public function lessThan($fieldNameAndPath, $operand): self
    {
        $this->lessThan[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
        return $this;
    }

    /**
     * @return array
     */
    public function getLessThanOrEqual(): array
    {
        return $this->lessThanOrEqual;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @return $this
     */
    public function lessThanOrEqual($fieldNameAndPath, $operand): self
    {
        $this->lessThanOrEqual[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
        return $this;
    }

    /**
     * @return array
     */
    public function getLike(): array
    {
        return $this->like;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @return $this
     */
    public function in($fieldNameAndPath, $operand): self
    {
        $this->in[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
        return $this;
    }

    /**
     * @return array
     */
    public function getIn(): array
    {
        return $this->in;
    }

    /**
     * @param $fieldNameAndPath
     * @param $operand
     * @param bool $addWildCard
     * @return $this
     */
    public function like($fieldNameAndPath, $operand, $addWildCard = true): self
    {
        $wildCardSymbol = $addWildCard ? '%' : '';
        $this->like[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $wildCardSymbol . $operand . $wildCardSymbol];
        return $this;
    }

    /**
     * @return string
     */
    public function getDefaultLogicalSeparator(): string
    {
        return $this->defaultLogicalSeparator;
    }

    /**
     * @param string $defaultLogicalSeparator
     * @return $this
     */
    public function setDefaultLogicalSeparator($defaultLogicalSeparator): self
    {
        $this->defaultLogicalSeparator = $defaultLogicalSeparator;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForEquals(): string
    {
        return $this->logicalSeparatorForEquals;
    }

    /**
     * @param string $logicalSeparatorForEquals
     * @return $this
     */
    public function setLogicalSeparatorForEquals($logicalSeparatorForEquals): self
    {
        $this->logicalSeparatorForEquals = $logicalSeparatorForEquals;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForGreaterThan(): string
    {
        return $this->logicalSeparatorForGreaterThan;
    }

    /**
     * @param string $logicalSeparatorForGreaterThan
     * @return $this
     */
    public function setLogicalSeparatorForGreaterThan($logicalSeparatorForGreaterThan): self
    {
        $this->logicalSeparatorForGreaterThan = $logicalSeparatorForGreaterThan;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForGreaterThanOrEqual(): string
    {
        return $this->logicalSeparatorForGreaterThanOrEqual;
    }

    /**
     * @param string $logicalSeparatorForGreaterThanOrEqual
     * @return $this
     */
    public function setLogicalSeparatorForGreaterThanOrEqual($logicalSeparatorForGreaterThanOrEqual): self
    {
        $this->logicalSeparatorForGreaterThanOrEqual = $logicalSeparatorForGreaterThanOrEqual;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForLessThan(): string
    {
        return $this->logicalSeparatorForLessThan;
    }

    /**
     * @param string $logicalSeparatorForLessThan
     * @return $this
     */
    public function setLogicalSeparatorForLessThan($logicalSeparatorForLessThan): self
    {
        $this->logicalSeparatorForLessThan = $logicalSeparatorForLessThan;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForLessThanOrEqual(): string
    {
        return $this->logicalSeparatorForLessThanOrEqual;
    }

    /**
     * @param string $logicalSeparatorForLessThanOrEqual
     * @return $this
     */
    public function setLogicalSeparatorForLessThanOrEqual($logicalSeparatorForLessThanOrEqual): self
    {
        $this->logicalSeparatorForLessThanOrEqual = $logicalSeparatorForLessThanOrEqual;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForIn(): string
    {
        return $this->logicalSeparatorForIn;
    }

    /**
     * @param string $logicalSeparatorForIn
     * @return $this
     */
    public function setLogicalSeparatorForIn($logicalSeparatorForIn): self
    {
        $this->logicalSeparatorForIn = $logicalSeparatorForIn;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForLike(): string
    {
        return $this->logicalSeparatorForLike;
    }

    /**
     * @param string $logicalSeparatorForLike
     * @return $this
     */
    public function setLogicalSeparatorForLike($logicalSeparatorForLike): self
    {
        $this->logicalSeparatorForLike = $logicalSeparatorForLike;
        return $this;
    }

    /**
     * @return string
     */
    public function getLogicalSeparatorForSearchTerm(): string
    {
        return $this->logicalSeparatorForSearchTerm;
    }

    /**
     * @param string $logicalSeparatorForSearchTerm
     * @return $this
     */
    public function setLogicalSeparatorForSearchTerm($logicalSeparatorForSearchTerm): self
    {
        $this->logicalSeparatorForSearchTerm = $logicalSeparatorForSearchTerm;
        return $this;
    }

    /**
     * @return array
     */
    public function getSupportedOperators(): array
    {
        return $this->supportedOperators;
    }

    /**
     * @return string
     */
    public function getDataType(): string
    {
        return $this->dataType;
    }

    /**
     * @param string $dataType
     * @return $this
     */
    public function setDataType($dataType): self
    {
        $this->dataType = $dataType;
        return $this;
    }
}


1			<?php
2			namespace Fab\Vidi\Persistence;
3
4			/*
5			* This file is part of the Fab/Vidi project under GPLv2 or later.
6			*
7			* For the full copyright and license information, please read the
8			* LICENSE.md file that was distributed with this source code.
9			*/
10
11			/**
12			* Matcher class for conditions that will apply to a query.
13			*/
14			class Matcher
15			{
16			/**
17			* The logical OR
18			*/
19			const LOGICAL_OR = 'logicalOr';
20
21			/**
22			* The logical AND
23			*/
24			const LOGICAL_AND = 'logicalAnd';
25
26			/**
27			* @var string
28			*/
29			protected $dataType = '';
30
31			/**
32			* @var string
33			*/
34			protected $searchTerm = '';
35
36			/**
37			* @var array
38			*/
39			protected $supportedOperators = [
40			'=' => 'equals',
41			'!=' => 'notEquals',
42			'in' => 'in',
43			'like' => 'like',
44			'>' => 'greaterThan',
45			'>=' => 'greaterThanOrEqual',
46			'<' => 'lessThan',
47			'<=' => 'lessThanOrEqual',
48			];
49
50			/**
51			* @var array
52			*/
53			protected $equals = [];
54
55			/**
56			* @var array
57			*/
58			protected $notEquals = [];
59
60			/**
61			* @var array
62			*/
63			protected $greaterThan = [];
64
65			/**
66			* @var array
67			*/
68			protected $greaterThanOrEqual = [];
69
70			/**
71			* @var array
72			*/
73			protected $lessThan = [];
74
75			/**
76			* @var array
77			*/
78			protected $lessThanOrEqual = [];
79
80			/**
81			* @var array
82			*/
83			protected $in = [];
84
85			/**
86			* @var array
87			*/
88			protected $like = [];
89
90			/**
91			* @var array
92			*/
93			protected $matches = [];
94
95			/**
96			* @var string
97			*/
98			protected $defaultLogicalSeparator = self::LOGICAL_AND;
99
100			/**
101			* @var string
102			*/
103			protected $logicalSeparatorForEquals = self::LOGICAL_AND;
104
105			/**
106			* @var string
107			*/
108			protected $logicalSeparatorForGreaterThan = self::LOGICAL_AND;
109
110			/**
111			* @var string
112			*/
113			protected $logicalSeparatorForGreaterThanOrEqual = self::LOGICAL_AND;
114
115			/**
116			* @var string
117			*/
118			protected $logicalSeparatorForLessThan = self::LOGICAL_AND;
119
120			/**
121			* @var string
122			*/
123			protected $logicalSeparatorForLessThanOrEqual = self::LOGICAL_AND;
124
125			/**
126			* @var string
127			*/
128			protected $logicalSeparatorForIn = self::LOGICAL_AND;
129
130			/**
131			* @var string
132			*/
133			protected $logicalSeparatorForLike = self::LOGICAL_AND;
134
135			/**
136			* @var string
137			*/
138			protected $logicalSeparatorForSearchTerm = self::LOGICAL_OR;
139
140			/**
141			* Constructs a new Matcher
142			*
143			* @param array $matches associative [$field => $value]
144			* @param string $dataType which corresponds to an entry of the TCA (table name).
145			*/
146			public function __construct($matches = [], $dataType = '')
147			{
148			$this->dataType = $dataType;
149			$this->matches = $matches;
150			}
151
152			/**
153			* @param string $searchTerm
154			* @return \Fab\Vidi\Persistence\Matcher
155			*/
156			public function setSearchTerm($searchTerm): Matcher
157			{
158			$this->searchTerm = $searchTerm;
159			return $this;
160			}
161
162			/**
163			* @return string
164			*/
165			public function getSearchTerm(): string
166			{
167			return $this->searchTerm;
168			}
169
170			/**
171			* @return array
172			*/
173			public function getEquals(): array
174			{
175			return $this->equals;
176			}
177
178			/**
179			* @param $fieldNameAndPath
180			* @param $operand
181			* @return $this
182			*/
183			public function equals($fieldNameAndPath, $operand): self
184			{
185			$this->equals[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
186			return $this;
187			}
188
189			/**
190			* @return array
191			*/
192			public function getNotEquals(): array
193			{
194			return $this->notEquals;
195			}
196
197			/**
198			* @param $fieldNameAndPath
199			* @param $operand
200			* @return $this
201			*/
202			public function notEquals($fieldNameAndPath, $operand): self
203			{
204			$this->notEquals[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
205			return $this;
206			}
207
208			/**
209			* @return array
210			*/
211			public function getGreaterThan(): array
212			{
213			return $this->greaterThan;
214			}
215
216			/**
217			* @param $fieldNameAndPath
218			* @param $operand
219			* @return $this
220			*/
221			public function greaterThan($fieldNameAndPath, $operand): self
222			{
223			$this->greaterThan[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
224			return $this;
225			}
226
227			/**
228			* @return array
229			*/
230			public function getGreaterThanOrEqual(): array
231			{
232			return $this->greaterThanOrEqual;
233			}
234
235			/**
236			* @param $fieldNameAndPath
237			* @param $operand
238			* @return $this
239			*/
240			public function greaterThanOrEqual($fieldNameAndPath, $operand): self
241			{
242			$this->greaterThanOrEqual[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
243			return $this;
244			}
245
246			/**
247			* @return array
248			*/
249			public function getLessThan(): array
250			{
251			return $this->lessThan;
252			}
253
254			/**
255			* @param $fieldNameAndPath
256			* @param $operand
257			* @return $this
258			*/
259			public function lessThan($fieldNameAndPath, $operand): self
260			{
261			$this->lessThan[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
262			return $this;
263			}
264
265			/**
266			* @return array
267			*/
268			public function getLessThanOrEqual(): array
269			{
270			return $this->lessThanOrEqual;
271			}
272
273			/**
274			* @param $fieldNameAndPath
275			* @param $operand
276			* @return $this
277			*/
278			public function lessThanOrEqual($fieldNameAndPath, $operand): self
279			{
280			$this->lessThanOrEqual[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
281			return $this;
282			}
283
284			/**
285			* @return array
286			*/
287			public function getLike(): array
288			{
289			return $this->like;
290			}
291
292			/**
293			* @param $fieldNameAndPath
294			* @param $operand
295			* @return $this
296			*/
297			public function in($fieldNameAndPath, $operand): self
298			{
299			$this->in[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $operand];
300			return $this;
301			}
302
303			/**
304			* @return array
305			*/
306			public function getIn(): array
307			{
308			return $this->in;
309			}
310
311			/**
312			* @param $fieldNameAndPath
313			* @param $operand
314			* @param bool $addWildCard
315			* @return $this
316			*/
317			public function like($fieldNameAndPath, $operand, $addWildCard = true): self
318			{
319			$wildCardSymbol = $addWildCard ? '%' : '';
320			$this->like[] = ['fieldNameAndPath' => $fieldNameAndPath, 'operand' => $wildCardSymbol . $operand . $wildCardSymbol];
321			return $this;
322			}
323
324			/**
325			* @return string
326			*/
327			public function getDefaultLogicalSeparator(): string
328			{
329			return $this->defaultLogicalSeparator;
330			}
331
332			/**
333			* @param string $defaultLogicalSeparator
334			* @return $this
335			*/
336			public function setDefaultLogicalSeparator($defaultLogicalSeparator): self
337			{
338			$this->defaultLogicalSeparator = $defaultLogicalSeparator;
339			return $this;
340			}
341
342			/**
343			* @return string
344			*/
345			public function getLogicalSeparatorForEquals(): string
346			{
347			return $this->logicalSeparatorForEquals;
348			}
349
350			/**
351			* @param string $logicalSeparatorForEquals
352			* @return $this
353			*/
354			public function setLogicalSeparatorForEquals($logicalSeparatorForEquals): self
355			{
356			$this->logicalSeparatorForEquals = $logicalSeparatorForEquals;
357			return $this;
358			}
359
360			/**
361			* @return string
362			*/
363			public function getLogicalSeparatorForGreaterThan(): string
364			{
365			return $this->logicalSeparatorForGreaterThan;
366			}
367
368			/**
369			* @param string $logicalSeparatorForGreaterThan
370			* @return $this
371			*/
372			public function setLogicalSeparatorForGreaterThan($logicalSeparatorForGreaterThan): self
373			{
374			$this->logicalSeparatorForGreaterThan = $logicalSeparatorForGreaterThan;
375			return $this;
376			}
377
378			/**
379			* @return string
380			*/
381			public function getLogicalSeparatorForGreaterThanOrEqual(): string
382			{
383			return $this->logicalSeparatorForGreaterThanOrEqual;
384			}
385
386			/**
387			* @param string $logicalSeparatorForGreaterThanOrEqual
388			* @return $this
389			*/
390			public function setLogicalSeparatorForGreaterThanOrEqual($logicalSeparatorForGreaterThanOrEqual): self
391			{
392			$this->logicalSeparatorForGreaterThanOrEqual = $logicalSeparatorForGreaterThanOrEqual;
393			return $this;
394			}
395
396			/**
397			* @return string
398			*/
399			public function getLogicalSeparatorForLessThan(): string
400			{
401			return $this->logicalSeparatorForLessThan;
402			}
403
404			/**
405			* @param string $logicalSeparatorForLessThan
406			* @return $this
407			*/
408			public function setLogicalSeparatorForLessThan($logicalSeparatorForLessThan): self
409			{
410			$this->logicalSeparatorForLessThan = $logicalSeparatorForLessThan;
411			return $this;
412			}
413
414			/**
415			* @return string
416			*/
417			public function getLogicalSeparatorForLessThanOrEqual(): string
418			{
419			return $this->logicalSeparatorForLessThanOrEqual;
420			}
421
422			/**
423			* @param string $logicalSeparatorForLessThanOrEqual
424			* @return $this
425			*/
426			public function setLogicalSeparatorForLessThanOrEqual($logicalSeparatorForLessThanOrEqual): self
427			{
428			$this->logicalSeparatorForLessThanOrEqual = $logicalSeparatorForLessThanOrEqual;
429			return $this;
430			}
431
432			/**
433			* @return string
434			*/
435			public function getLogicalSeparatorForIn(): string
436			{
437			return $this->logicalSeparatorForIn;
438			}
439
440			/**
441			* @param string $logicalSeparatorForIn
442			* @return $this
443			*/
444			public function setLogicalSeparatorForIn($logicalSeparatorForIn): self
445			{
446			$this->logicalSeparatorForIn = $logicalSeparatorForIn;
447			return $this;
448			}
449
450			/**
451			* @return string
452			*/
453			public function getLogicalSeparatorForLike(): string
454			{
455			return $this->logicalSeparatorForLike;
456			}
457
458			/**
459			* @param string $logicalSeparatorForLike
460			* @return $this
461			*/
462			public function setLogicalSeparatorForLike($logicalSeparatorForLike): self
463			{
464			$this->logicalSeparatorForLike = $logicalSeparatorForLike;
465			return $this;
466			}
467
468			/**
469			* @return string
470			*/
471			public function getLogicalSeparatorForSearchTerm(): string
472			{
473			return $this->logicalSeparatorForSearchTerm;
474			}
475
476			/**
477			* @param string $logicalSeparatorForSearchTerm
478			* @return $this
479			*/
480			public function setLogicalSeparatorForSearchTerm($logicalSeparatorForSearchTerm): self
481			{
482			$this->logicalSeparatorForSearchTerm = $logicalSeparatorForSearchTerm;
483			return $this;
484			}
485
486			/**
487			* @return array
488			*/
489			public function getSupportedOperators(): array
490			{
491			return $this->supportedOperators;
492			}
493
494			/**
495			* @return string
496			*/
497			public function getDataType(): string
498			{
499			return $this->dataType;
500			}
501
502			/**
503			* @param string $dataType
504			* @return $this
505			*/
506			public function setDataType($dataType): self
507			{
508			$this->dataType = $dataType;
509			return $this;
510			}
511			}
512

fabarea / vidi

Push — master ( 3efc81...a16fdb )

Matcher A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

40 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like