Criteria::andOffset() - Code Metrics - Inspection of "WIP: Drop php versions < 7.1, do refactoring, add..." - tarantool-php/client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#37)

by Eugene

created 2019-04-18 20:55 UTC

Criteria::andOffset() A

↳ Parent: Criteria

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	3
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Tarantool Client package.
 *
 * (c) Eugene Leonovich <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tarantool\Client\Schema;

final class Criteria
{
    private $index = 0;
    private $key = [];
    private $limit = \PHP_INT_MAX & 0xffffffff;
    private $offset = 0;
    private $iteratorType = IteratorTypes::EQ;

    private function __construct()
    {
    }

    public static function index($index) : self
    {
        $self = new self();
        $self->index = $index;

        return $self;
    }

    public function andIndex($index) : self
    {
        $new = clone $this;
        $new->index = $index;

        return $new;
    }

    public function getIndex()
    {
        return $this->index;
    }

    public static function key(array $key) : self
    {
        $self = new self();
        $self->key = $key;

        return $self;
    }

    public function andKey(array $key) : self
    {
        $new = clone $this;
        $new->key = $key;

        return $new;
    }

    public function getKey() : array
    {
        return $this->key;
    }

    public static function limit(int $limit) : self
    {
        $self = new self();
        $self->limit = $limit;

        return $self;
    }

    public function andLimit(int $limit) : self
    {
        $new = clone $this;
        $new->limit = $limit;

        return $new;
    }

    public function getLimit() : int
    {
        return $this->limit;
    }

    public static function offset(int $offset) : self
    {
        $self = new self();
        $self->offset = $offset;

        return $self;
    }

    public function andOffset(int $offset) : self
    {
        $new = clone $this;
        $new->offset = $offset;

        return $new;
    }

    public function getOffset() : int
    {
        return $this->offset;
    }

    public static function eqIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::EQ;

        return $self;
    }

    public function andEqIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::EQ;

        return $new;
    }

    public static function reqIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::REQ;

        return $self;
    }

    public function andReqIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::REQ;

        return $new;
    }

    public static function allIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::ALL;

        return $self;
    }

    public function andAllIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::ALL;

        return $new;
    }

    public static function ltIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::LT;

        return $self;
    }

    public function andLtIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::LT;

        return $new;
    }

    public static function leIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::LE;

        return $self;
    }

    public function andLeIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::LE;

        return $new;
    }

    public static function geIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::GE;

        return $self;
    }

    public function andGeIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::GE;

        return $new;
    }

    public static function gtIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::GT;

        return $self;
    }

    public function andGtIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::GT;

        return $new;
    }

    public static function bitsAllSetIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::BITS_ALL_SET;

        return $self;
    }

    public function andBitsAllSetIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::BITS_ALL_SET;

        return $new;
    }

    public static function bitsAnySetIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::BITS_ANY_SET;

        return $self;
    }

    public function andBitsAnySetIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::BITS_ANY_SET;

        return $new;
    }

    public static function bitsAllNotSetIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::BITS_ALL_NOT_SET;

        return $self;
    }

    public function andBitsAllNotSetIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::BITS_ALL_NOT_SET;

        return $new;
    }

    public static function overlapsIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::OVERLAPS;

        return $self;
    }

    public function andOverlapsIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::OVERLAPS;

        return $new;
    }

    public static function neighborIterator() : self
    {
        $self = new self();
        $self->iteratorType = IteratorTypes::NEIGHBOR;

        return $self;
    }

    public function andNeighborIterator() : self
    {
        $new = clone $this;
        $new->iteratorType = IteratorTypes::NEIGHBOR;

        return $new;
    }

    public function getIteratorType() : int
    {
        return $this->iteratorType;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Tarantool Client package.
7			*
8			* (c) Eugene Leonovich <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Tarantool\Client\Schema;
15
16			final class Criteria
17			{
18			private $index = 0;
19			private $key = [];
20			private $limit = \PHP_INT_MAX & 0xffffffff;
21			private $offset = 0;
22			private $iteratorType = IteratorTypes::EQ;
23
24			private function __construct()
25			{
26			}
27
28			public static function index($index) : self
29			{
30			$self = new self();
31			$self->index = $index;
32
33			return $self;
34			}
35
36			public function andIndex($index) : self
37			{
38			$new = clone $this;
39			$new->index = $index;
40
41			return $new;
42			}
43
44			public function getIndex()
45			{
46			return $this->index;
47			}
48
49			public static function key(array $key) : self
50			{
51			$self = new self();
52			$self->key = $key;
53
54			return $self;
55			}
56
57			public function andKey(array $key) : self
58			{
59			$new = clone $this;
60			$new->key = $key;
61
62			return $new;
63			}
64
65			public function getKey() : array
66			{
67			return $this->key;
68			}
69
70			public static function limit(int $limit) : self
71			{
72			$self = new self();
73			$self->limit = $limit;
74
75			return $self;
76			}
77
78			public function andLimit(int $limit) : self
79			{
80			$new = clone $this;
81			$new->limit = $limit;
82
83			return $new;
84			}
85
86			public function getLimit() : int
87			{
88			return $this->limit;
89			}
90
91			public static function offset(int $offset) : self
92			{
93			$self = new self();
94			$self->offset = $offset;
95
96			return $self;
97			}
98
99			public function andOffset(int $offset) : self
100			{
101			$new = clone $this;
102			$new->offset = $offset;
103
104			return $new;
105			}
106
107			public function getOffset() : int
108			{
109			return $this->offset;
110			}
111
112			public static function eqIterator() : self
113			{
114			$self = new self();
115			$self->iteratorType = IteratorTypes::EQ;
116
117			return $self;
118			}
119
120			public function andEqIterator() : self
121			{
122			$new = clone $this;
123			$new->iteratorType = IteratorTypes::EQ;
124
125			return $new;
126			}
127
128			public static function reqIterator() : self
129			{
130			$self = new self();
131			$self->iteratorType = IteratorTypes::REQ;
132
133			return $self;
134			}
135
136			public function andReqIterator() : self
137			{
138			$new = clone $this;
139			$new->iteratorType = IteratorTypes::REQ;
140
141			return $new;
142			}
143
144			public static function allIterator() : self
145			{
146			$self = new self();
147			$self->iteratorType = IteratorTypes::ALL;
148
149			return $self;
150			}
151
152			public function andAllIterator() : self
153			{
154			$new = clone $this;
155			$new->iteratorType = IteratorTypes::ALL;
156
157			return $new;
158			}
159
160			public static function ltIterator() : self
161			{
162			$self = new self();
163			$self->iteratorType = IteratorTypes::LT;
164
165			return $self;
166			}
167
168			public function andLtIterator() : self
169			{
170			$new = clone $this;
171			$new->iteratorType = IteratorTypes::LT;
172
173			return $new;
174			}
175
176			public static function leIterator() : self
177			{
178			$self = new self();
179			$self->iteratorType = IteratorTypes::LE;
180
181			return $self;
182			}
183
184			public function andLeIterator() : self
185			{
186			$new = clone $this;
187			$new->iteratorType = IteratorTypes::LE;
188
189			return $new;
190			}
191
192			public static function geIterator() : self
193			{
194			$self = new self();
195			$self->iteratorType = IteratorTypes::GE;
196
197			return $self;
198			}
199
200			public function andGeIterator() : self
201			{
202			$new = clone $this;
203			$new->iteratorType = IteratorTypes::GE;
204
205			return $new;
206			}
207
208			public static function gtIterator() : self
209			{
210			$self = new self();
211			$self->iteratorType = IteratorTypes::GT;
212
213			return $self;
214			}
215
216			public function andGtIterator() : self
217			{
218			$new = clone $this;
219			$new->iteratorType = IteratorTypes::GT;
220
221			return $new;
222			}
223
224			public static function bitsAllSetIterator() : self
225			{
226			$self = new self();
227			$self->iteratorType = IteratorTypes::BITS_ALL_SET;
228
229			return $self;
230			}
231
232			public function andBitsAllSetIterator() : self
233			{
234			$new = clone $this;
235			$new->iteratorType = IteratorTypes::BITS_ALL_SET;
236
237			return $new;
238			}
239
240			public static function bitsAnySetIterator() : self
241			{
242			$self = new self();
243			$self->iteratorType = IteratorTypes::BITS_ANY_SET;
244
245			return $self;
246			}
247
248			public function andBitsAnySetIterator() : self
249			{
250			$new = clone $this;
251			$new->iteratorType = IteratorTypes::BITS_ANY_SET;
252
253			return $new;
254			}
255
256			public static function bitsAllNotSetIterator() : self
257			{
258			$self = new self();
259			$self->iteratorType = IteratorTypes::BITS_ALL_NOT_SET;
260
261			return $self;
262			}
263
264			public function andBitsAllNotSetIterator() : self
265			{
266			$new = clone $this;
267			$new->iteratorType = IteratorTypes::BITS_ALL_NOT_SET;
268
269			return $new;
270			}
271
272			public static function overlapsIterator() : self
273			{
274			$self = new self();
275			$self->iteratorType = IteratorTypes::OVERLAPS;
276
277			return $self;
278			}
279
280			public function andOverlapsIterator() : self
281			{
282			$new = clone $this;
283			$new->iteratorType = IteratorTypes::OVERLAPS;
284
285			return $new;
286			}
287
288			public static function neighborIterator() : self
289			{
290			$self = new self();
291			$self->iteratorType = IteratorTypes::NEIGHBOR;
292
293			return $self;
294			}
295
296			public function andNeighborIterator() : self
297			{
298			$new = clone $this;
299			$new->iteratorType = IteratorTypes::NEIGHBOR;
300
301			return $new;
302			}
303
304			public function getIteratorType() : int
305			{
306			return $this->iteratorType;
307			}
308			}
309

tarantool-php / client

Pull Request — master (#37)

Criteria::andOffset() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like