Line data Source code
1 : /**
2 : Copyright (c) 2016-2022 Roman Katuntsev <sbkarr@stappler.org>
3 : Copyright (c) 2023 Stappler LLC <admin@stappler.dev>
4 :
5 : Permission is hereby granted, free of charge, to any person obtaining a copy
6 : of this software and associated documentation files (the "Software"), to deal
7 : in the Software without restriction, including without limitation the rights
8 : to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 : copies of the Software, and to permit persons to whom the Software is
10 : furnished to do so, subject to the following conditions:
11 :
12 : The above copyright notice and this permission notice shall be included in
13 : all copies or substantial portions of the Software.
14 :
15 : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 : IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 : FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 : AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 : LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 : OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 : THE SOFTWARE.
22 : **/
23 :
24 : #ifndef STAPPLER_CORE_STRING_SPDATAREADER_H_
25 : #define STAPPLER_CORE_STRING_SPDATAREADER_H_
26 :
27 : #include "SPByteOrder.h"
28 : #include "SPStringView.h"
29 : #include "SPHalfFloat.h"
30 :
31 : namespace STAPPLER_VERSIONIZED stappler {
32 :
33 : template <Endian Endianess = Endian::Network>
34 : class BytesViewTemplate : public BytesReader<uint8_t> {
35 : public:
36 : template <class T>
37 : using Converter = byteorder::ConverterTraits<Endianess, T>;
38 :
39 : using Self = BytesViewTemplate<Endianess>;
40 :
41 : using PoolBytes = typename memory::PoolInterface::BytesType;
42 : using StdBytes = typename memory::StandartInterface::BytesType;
43 :
44 : constexpr BytesViewTemplate();
45 : constexpr BytesViewTemplate(const uint8_t *p, size_t l);
46 : constexpr BytesViewTemplate(StringView);
47 :
48 : BytesViewTemplate(const PoolBytes &vec);
49 : BytesViewTemplate(const StdBytes &vec);
50 :
51 : template <size_t Size>
52 : constexpr BytesViewTemplate(const std::array<uint8_t, Size> &arr);
53 :
54 : template<Endian OtherEndianess>
55 : constexpr BytesViewTemplate(const BytesViewTemplate<OtherEndianess> &vec);
56 :
57 : template<Endian OtherEndianess>
58 : constexpr BytesViewTemplate(const BytesViewTemplate<OtherEndianess>, size_t len);
59 :
60 : template<Endian OtherEndianess>
61 : constexpr BytesViewTemplate(const BytesViewTemplate<OtherEndianess>, size_t pos, size_t len);
62 :
63 : Self & operator =(const PoolBytes &b);
64 : Self & operator =(const StdBytes &b);
65 : Self & operator =(const Self &b);
66 :
67 : Self & set(const PoolBytes &vec);
68 : Self & set(const StdBytes &vec);
69 : Self & set(const Self &vec);
70 : Self & set(const uint8_t *p, size_t l);
71 :
72 : Self & operator ++ ();
73 : Self & operator ++ (int);
74 : Self & operator += (size_t l);
75 :
76 : bool operator == (const Self &other) const;
77 : bool operator != (const Self &other) const;
78 :
79 : Self pdup(memory::pool_t * = nullptr) const;
80 :
81 : template <typename Interface>
82 : auto bytes() const -> typename Interface::BytesType;
83 :
84 127 : constexpr Self sub(size_t pos = 0, size_t len = maxOf<size_t>()) const { return Self(*this, pos, len); }
85 :
86 : private:
87 : template <typename T>
88 : auto convert(const uint8_t *data) -> T;
89 :
90 : bool match (CharType c) { return false; }
91 : template <uint8_t Arg, uint8_t ... Args> bool match (CharType c);
92 :
93 : public:
94 : template<uint8_t ... Args> void skipChars();
95 : template<uint8_t ... Args> void skipUntil();
96 :
97 : template<uint8_t ... Args> void backwardSkipChars();
98 : template<uint8_t ... Args> void backwardSkipUntil();
99 :
100 : template<uint8_t ... Args> Self readChars();
101 : template<uint8_t ... Args> Self readUntil();
102 :
103 : template<uint8_t ... Args> Self backwardReadChars();
104 : template<uint8_t ... Args> Self backwardReadUntil();
105 :
106 : template <uint8_t ... Args> void trimChars();
107 : template <uint8_t ... Args> void trimUntil();
108 :
109 : template<typename Separator, typename Callback> void split(const Callback &cb) const;
110 :
111 : uint64_t readUnsigned64();
112 : uint32_t readUnsigned32();
113 : uint32_t readUnsigned24();
114 : uint16_t readUnsigned16();
115 : uint8_t readUnsigned();
116 :
117 : double readFloat64();
118 : float readFloat32();
119 : float readFloat16();
120 :
121 : StringView readString(); // read null-terminated string
122 : StringView readString(size_t s); // read fixed-size string
123 :
124 : StringView toStringView() const;
125 :
126 : template<Endian OtherEndianess = Endianess>
127 : auto readBytes(size_t s) -> BytesViewTemplate<OtherEndianess>; // read fixed-size string
128 : };
129 :
130 : using BytesView = BytesViewTemplate<Endian::Host>;
131 : using BytesViewNetwork = BytesViewTemplate<Endian::Network>;
132 : using BytesViewHost = BytesViewTemplate<Endian::Host>;
133 :
134 : template <Endian Endianess>
135 877383 : inline constexpr BytesViewTemplate<Endianess>::BytesViewTemplate() { }
136 :
137 : template <Endian Endianess>
138 2545972 : inline constexpr BytesViewTemplate<Endianess>::BytesViewTemplate(const uint8_t *p, size_t l)
139 2545972 : : BytesReader(p, l) { }
140 :
141 : template <Endian Endianess>
142 900 : BytesViewTemplate<Endianess>::BytesViewTemplate(const PoolBytes &vec)
143 900 : : BytesReader(vec.data(), vec.size()) { }
144 :
145 : template <Endian Endianess>
146 448860 : BytesViewTemplate<Endianess>::BytesViewTemplate(const StdBytes &vec)
147 448860 : : BytesReader(vec.data(), vec.size()) { }
148 :
149 : template <Endian Endianess>
150 1650 : inline constexpr BytesViewTemplate<Endianess>::BytesViewTemplate(StringView str)
151 1650 : : BytesReader((const uint8_t *)str.data(), str.size()) { }
152 :
153 : template <Endian Endianess>
154 : template <size_t Size>
155 1225 : inline constexpr BytesViewTemplate<Endianess>::BytesViewTemplate(const std::array<uint8_t, Size> &arr)
156 1225 : : BytesReader(arr.data(), Size) { }
157 :
158 : template <Endian Endianess>
159 : template<Endian OtherEndianess>
160 553381 : inline constexpr BytesViewTemplate<Endianess>::BytesViewTemplate(const BytesViewTemplate<OtherEndianess> &data)
161 553381 : : BytesReader(data.data(), data.size()) { }
162 :
163 : template <Endian Endianess>
164 : template<Endian OtherEndianess>
165 775 : inline constexpr BytesViewTemplate<Endianess>::BytesViewTemplate(const BytesViewTemplate<OtherEndianess> ptr, size_t len)
166 775 : : BytesReader(ptr.data(), min(len, ptr.size())) { }
167 :
168 : template <Endian Endianess>
169 : template<Endian OtherEndianess>
170 152 : inline constexpr BytesViewTemplate<Endianess>::BytesViewTemplate(const BytesViewTemplate<OtherEndianess> ptr, size_t pos, size_t len)
171 152 : : BytesReader(ptr.data() + pos, min(len, ptr.size() - pos)) { }
172 :
173 :
174 : template <Endian Endianess>
175 : auto BytesViewTemplate<Endianess>::operator =(const PoolBytes &b) -> Self & {
176 : return set(b);
177 : }
178 :
179 : template <Endian Endianess>
180 80 : auto BytesViewTemplate<Endianess>::operator =(const StdBytes &b) -> Self & {
181 80 : return set(b);
182 : }
183 :
184 : template <Endian Endianess>
185 45472 : auto BytesViewTemplate<Endianess>::operator =(const Self &b) -> Self & {
186 45472 : return set(b);
187 : }
188 :
189 : template <Endian Endianess>
190 : auto BytesViewTemplate<Endianess>::set(const PoolBytes &vec) -> Self & {
191 : ptr = vec.data();
192 : len = vec.size();
193 : return *this;
194 : }
195 :
196 : template <Endian Endianess>
197 80 : auto BytesViewTemplate<Endianess>::set(const StdBytes &vec) -> Self & {
198 80 : ptr = vec.data();
199 80 : len = vec.size();
200 80 : return *this;
201 : }
202 :
203 : template <Endian Endianess>
204 45472 : auto BytesViewTemplate<Endianess>::set(const Self &vec) -> Self & {
205 45472 : ptr = vec.data();
206 45472 : len = vec.size();
207 45470 : return *this;
208 : }
209 :
210 : template <Endian Endianess>
211 : auto BytesViewTemplate<Endianess>::set(const uint8_t *p, size_t l) -> Self & {
212 : ptr = p;
213 : len = l;
214 : return *this;
215 : }
216 :
217 : template <Endian Endianess>
218 20675 : auto BytesViewTemplate<Endianess>::operator ++ () -> Self & {
219 20675 : if (len > 0) {
220 20675 : ptr ++; len --;
221 : }
222 20675 : return *this;
223 : }
224 :
225 : template <Endian Endianess>
226 25325 : auto BytesViewTemplate<Endianess>::operator ++ (int) -> Self & {
227 25325 : if (len > 0) {
228 25325 : ptr ++; len --;
229 : }
230 25325 : return *this;
231 : }
232 :
233 : template <Endian Endianess>
234 4489668 : auto BytesViewTemplate<Endianess>::operator += (size_t l) -> Self & {
235 4489668 : if (len > 0) {
236 4488843 : offset(l);
237 : }
238 4489668 : return *this;
239 : }
240 :
241 : template <Endian Endianess>
242 1325 : auto BytesViewTemplate<Endianess>::operator == (const Self &other) const -> bool {
243 1325 : return len == other.len && (ptr == other.ptr || memcmp(ptr, other.ptr, len * sizeof(CharType)) == 0);
244 : }
245 :
246 : template <Endian Endianess>
247 975 : auto BytesViewTemplate<Endianess>::operator != (const Self &other) const -> bool {
248 975 : return !(*this == other);
249 : }
250 :
251 : template <Endian Endianess>
252 125 : auto BytesViewTemplate<Endianess>::pdup(memory::pool_t *p) const -> Self {
253 125 : if (!p) {
254 0 : p = memory::pool::acquire();
255 : }
256 125 : auto buf = (uint8_t *)memory::pool::palloc(p, this->size() * sizeof(uint8_t));
257 125 : memcpy(buf, this->data(), this->size() * sizeof(uint8_t));
258 125 : return Self(buf, this->size());
259 : }
260 :
261 : template <Endian Endianess>
262 : template <typename Interface>
263 5680 : auto BytesViewTemplate<Endianess>::bytes() const -> typename Interface::BytesType {
264 5680 : return typename Interface::BytesType(data(), data() + size());
265 : }
266 :
267 : template <Endian Endianess>
268 : template <typename T>
269 23399047 : auto BytesViewTemplate<Endianess>::convert(const uint8_t *data) -> T {
270 : T res;
271 23399047 : memcpy(&res, data, sizeof(T));
272 46741693 : return Converter<T>::Swap(res);
273 : };
274 :
275 : template <Endian Endianess>
276 : template<uint8_t ... Args>
277 : auto BytesViewTemplate<Endianess>::skipChars() -> void {
278 : size_t offset = 0;
279 : while (this->len > offset && match<Args...>(this->ptr[offset])) {
280 : ++offset;
281 : }
282 : auto off = std::min(offset, this->len);
283 : this->len -= off;
284 : this->ptr += off;
285 : }
286 :
287 : template <Endian Endianess>
288 : template<uint8_t ... Args>
289 38775 : auto BytesViewTemplate<Endianess>::skipUntil() -> void {
290 38775 : size_t offset = 0;
291 2356950 : while (this->len > offset && !match<Args...>(this->ptr[offset])) {
292 2318175 : ++offset;
293 : }
294 38775 : auto off = std::min(offset, this->len);
295 38775 : this->len -= off;
296 38775 : this->ptr += off;
297 38775 : }
298 :
299 : template <Endian Endianess>
300 : template<uint8_t ... Args>
301 : auto BytesViewTemplate<Endianess>::backwardSkipChars() -> void {
302 : while (this->len > 0 && match<Args...>(this->ptr[this->len - 1])) {
303 : -- this->len;
304 : }
305 : }
306 :
307 : template <Endian Endianess>
308 : template<uint8_t ... Args>
309 : auto BytesViewTemplate<Endianess>::backwardSkipUntil() -> void {
310 : while (this->len > 0 && !match<Args...>(this->ptr[this->len - 1])) {
311 : -- this->len;
312 : }
313 : }
314 :
315 : template <Endian Endianess>
316 : template <uint8_t ... Args>
317 : auto BytesViewTemplate<Endianess>::readChars() -> Self {
318 : auto tmp = *this;
319 : skipChars<Args ...>();
320 : return Self(tmp.data(), tmp.size() - this->size());
321 : }
322 :
323 : template <Endian Endianess>
324 : template <uint8_t ... Args>
325 38775 : auto BytesViewTemplate<Endianess>::readUntil() -> Self {
326 38775 : auto tmp = *this;
327 38775 : skipUntil<Args ...>();
328 38775 : return Self(tmp.data(), tmp.size() - this->size());
329 : }
330 :
331 : template <Endian Endianess>
332 : template<uint8_t ... Args>
333 : auto BytesViewTemplate<Endianess>::backwardReadChars() -> Self {
334 : auto tmp = *this;
335 : backwardSkipChars<Args ...>();
336 : return Self(this->data() + this->size(), tmp.size() - this->size());
337 : }
338 :
339 : template <Endian Endianess>
340 : template<uint8_t ... Args>
341 : auto BytesViewTemplate<Endianess>::backwardReadUntil() -> Self {
342 : auto tmp = *this;
343 : backwardSkipUntil<Args ...>();
344 : return Self(this->data() + this->size(), tmp.size() - this->size());
345 : }
346 :
347 : template <Endian Endianess>
348 : template<typename Separator, typename Callback>
349 : auto BytesViewTemplate<Endianess>::split(const Callback &cb) const -> void {
350 : Self str(*this);
351 : while (!str.empty()) {
352 : str.skipChars<Separator>();
353 : auto tmp = str.readUntil<Separator>();
354 : if (!tmp.empty()) {
355 : cb(tmp);
356 : }
357 : }
358 : }
359 :
360 : template <Endian Endianess>
361 : template<uint8_t ... Args>
362 : auto BytesViewTemplate<Endianess>::trimChars() -> void {
363 : this->skipChars<Args...>();
364 : if (!this->empty()) {
365 : this->backwardSkipChars<Args...>();
366 : }
367 : }
368 :
369 : template <Endian Endianess>
370 : template <uint8_t... Args>
371 : auto BytesViewTemplate<Endianess>::trimUntil() -> void {
372 : this->skipUntil<Args...>();
373 : if (!this->empty()) {
374 : this->backwardSkipUntil<Args...>();
375 : }
376 : }
377 :
378 : template <Endian Endianess>
379 : template <uint8_t Arg, uint8_t ...Args>
380 2356725 : auto BytesViewTemplate<Endianess>::match(CharType c) -> bool {
381 2356725 : if (c == Arg) {
382 38550 : return true;
383 : }
384 : if constexpr (sizeof...(Args) > 0) {
385 : return match<Args...>(c);
386 : }
387 2318175 : return false;
388 : }
389 :
390 : template <Endian Endianess>
391 10450 : auto BytesViewTemplate<Endianess>::readUnsigned64() -> uint64_t {
392 10450 : uint64_t ret = 0;
393 10450 : if (len >= 8) {
394 10450 : ret = convert<uint64_t>(ptr);
395 10450 : ptr += 8; len -= 8;
396 : }
397 10450 : return ret;
398 : }
399 :
400 : template <Endian Endianess>
401 268120 : auto BytesViewTemplate<Endianess>::readUnsigned32() -> uint32_t {
402 268120 : uint32_t ret = 0;
403 268120 : if (len >= 4) {
404 268120 : ret = convert<uint32_t>(ptr);
405 268119 : ptr += 4; len -= 4;
406 : }
407 268119 : return ret;
408 : }
409 :
410 : template <Endian Endianess>
411 325 : auto BytesViewTemplate<Endianess>::readUnsigned24() -> uint32_t {
412 325 : uint32_t ret = 0;
413 325 : if (len >= 3) {
414 325 : ret = (*ptr << 16) + (*(ptr + 1) << 8) + *(ptr + 2);
415 325 : ptr += 3; len -= 3;
416 : }
417 325 : return ret;
418 : }
419 :
420 : template <Endian Endianess>
421 4514981 : auto BytesViewTemplate<Endianess>::readUnsigned16() -> uint16_t {
422 4514981 : uint16_t ret = 0;
423 4514981 : if (len >= 2) {
424 4514956 : ret = convert<uint16_t>(ptr);
425 4514957 : ptr += 2; len -= 2;
426 : }
427 4514982 : return ret;
428 : }
429 :
430 : template <Endian Endianess>
431 80574947 : auto BytesViewTemplate<Endianess>::readUnsigned() -> uint8_t {
432 80574947 : uint8_t ret = 0;
433 80574947 : if (len > 0) { ret = *ptr; ++ ptr; -- len; }
434 80574947 : return ret;
435 : }
436 :
437 : template <Endian Endianess>
438 1325 : auto BytesViewTemplate<Endianess>::readFloat64() -> double{
439 1325 : double ret = 0;
440 1325 : if (len >= 8) {
441 1325 : ret = convert<double>(ptr);
442 1325 : ptr += 8; len -= 8;
443 : }
444 1325 : return ret;
445 : }
446 :
447 : template <Endian Endianess>
448 18604198 : auto BytesViewTemplate<Endianess>::readFloat32() -> float {
449 18604198 : float ret = 0; if (len >= 4) {
450 18604198 : ret = convert<float>(ptr);
451 18604198 : ptr += 4; len -= 4;
452 : }
453 18604198 : return ret;
454 : }
455 :
456 : template <Endian Endianess>
457 3717009 : auto BytesViewTemplate<Endianess>::readFloat16() -> float {
458 3717009 : return halffloat::decode(readUnsigned16());
459 : }
460 :
461 : // read null-terminated string
462 : template <Endian Endianess>
463 : auto BytesViewTemplate<Endianess>::readString() -> StringView {
464 : size_t offset = 0; while (len - offset && ptr[offset]) { offset ++; }
465 : StringView ret((const char *)ptr, offset);
466 : ptr += offset; len -= offset;
467 : if (len && *ptr == 0) { ++ ptr; -- len; }
468 : return ret;
469 : }
470 :
471 : // read fixed-size string
472 : template <Endian Endianess>
473 4675 : auto BytesViewTemplate<Endianess>::readString(size_t s) -> StringView {
474 4675 : if (len < s) {
475 0 : s = len;
476 : }
477 4675 : StringView ret((const char *)ptr, s);
478 4675 : ptr += s; len -= s;
479 4675 : return ret;
480 : }
481 :
482 : template <Endian Endianess>
483 49850 : auto BytesViewTemplate<Endianess>::toStringView() const -> StringView {
484 49850 : return StringView((const char *)ptr, len);
485 : }
486 :
487 : template <Endian Endianess>
488 : template <Endian Target>
489 4450 : auto BytesViewTemplate<Endianess>::readBytes(size_t s) -> BytesViewTemplate<Target> {
490 4450 : if (len < s) {
491 0 : s = len;
492 : }
493 4450 : BytesViewTemplate<Target> ret(ptr, s);
494 4450 : ptr += s; len -= s;
495 4450 : return ret;
496 : }
497 :
498 :
499 :
500 : template <typename Compare>
501 : inline int compareDataRanges(const uint8_t *l, size_t __lsize, const uint8_t *r, size_t __rsize, const Compare &cmp) {
502 : return std::lexicographical_compare(l, l + __lsize, r, r + __rsize, cmp);
503 : }
504 :
505 : template <Endian Endianess>
506 : inline bool operator== (const memory::PoolInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
507 : return BytesViewTemplate<Endianess>(l) == r;
508 : }
509 :
510 : template <Endian Endianess>
511 : inline bool operator== (const memory::StandartInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
512 : return BytesViewTemplate<Endianess>(l) == r;
513 : }
514 :
515 : template <Endian Endianess, size_t Size>
516 200 : inline bool operator== (const std::array<uint8_t, Size> &l, const BytesViewTemplate<Endianess> &r) {
517 200 : return BytesViewTemplate<Endianess>(l) == r;
518 : }
519 :
520 : template <Endian Endianess>
521 : inline bool operator== (const BytesViewTemplate<Endianess> &l, const memory::PoolInterface::BytesType &r) {
522 : return l == BytesViewTemplate<Endianess>(r);
523 : }
524 :
525 : template <Endian Endianess>
526 : inline bool operator== (const BytesViewTemplate<Endianess> &l, const memory::StandartInterface::BytesType &r) {
527 : return l == BytesViewTemplate<Endianess>(r);
528 : }
529 :
530 : template <Endian Endianess, size_t Size>
531 : inline bool operator== (const BytesViewTemplate<Endianess> &l, const std::array<uint8_t, Size> &r) {
532 : return l == BytesViewTemplate<Endianess>(r);
533 : }
534 :
535 :
536 : template <Endian Endianess>
537 : inline bool operator!= (const memory::PoolInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
538 : return BytesViewTemplate<Endianess>(l) != r;
539 : }
540 :
541 : template <Endian Endianess>
542 325 : inline bool operator!= (const memory::StandartInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
543 325 : return BytesViewTemplate<Endianess>(l) != r;
544 : }
545 :
546 : template <Endian Endianess, size_t Size>
547 : inline bool operator!= (const std::array<uint8_t, Size> &l, const BytesViewTemplate<Endianess> &r) {
548 : return BytesViewTemplate<Endianess>(l) != r;
549 : }
550 :
551 : template <Endian Endianess>
552 : inline bool operator!= (const BytesViewTemplate<Endianess> &l, const memory::PoolInterface::BytesType &r) {
553 : return l != BytesViewTemplate<Endianess>(r);
554 : }
555 :
556 : template <Endian Endianess>
557 : inline bool operator!= (const BytesViewTemplate<Endianess> &l, const memory::StandartInterface::BytesType &r) {
558 : return l != BytesViewTemplate<Endianess>(r);
559 : }
560 :
561 : template <Endian Endianess, size_t Size>
562 : inline bool operator!= (const BytesViewTemplate<Endianess> &l, const std::array<uint8_t, Size> &r) {
563 : return l != BytesViewTemplate<Endianess>(r);
564 : }
565 :
566 :
567 : template <Endian Endianess>
568 : inline bool operator< (const BytesViewTemplate<Endianess> &l, const BytesViewTemplate<Endianess> &r) {
569 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less<uint8_t>());
570 : }
571 :
572 : template <Endian Endianess>
573 : inline bool operator< (const memory::PoolInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
574 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less<uint8_t>());
575 : }
576 :
577 : template <Endian Endianess>
578 : inline bool operator< (const memory::StandartInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
579 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less<uint8_t>());
580 : }
581 :
582 : template <Endian Endianess>
583 : inline bool operator< (const BytesViewTemplate<Endianess> &l, const memory::PoolInterface::BytesType &r) {
584 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less<uint8_t>());
585 : }
586 :
587 : template <Endian Endianess>
588 : inline bool operator< (const BytesViewTemplate<Endianess> &l, const memory::StandartInterface::BytesType &r) {
589 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less<uint8_t>());
590 : }
591 :
592 :
593 : template <Endian Endianess>
594 : inline bool operator<= (const BytesViewTemplate<Endianess> &l, const BytesViewTemplate<Endianess> &r) {
595 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less_equal<uint8_t>());
596 : }
597 :
598 : template <Endian Endianess>
599 : inline bool operator<= (const memory::PoolInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
600 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less_equal<uint8_t>());
601 : }
602 :
603 : template <Endian Endianess>
604 : inline bool operator<= (const memory::StandartInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
605 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less_equal<uint8_t>());
606 : }
607 :
608 : template <Endian Endianess>
609 : inline bool operator<= (const BytesViewTemplate<Endianess> &l, const memory::PoolInterface::BytesType &r) {
610 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less_equal<uint8_t>());
611 : }
612 :
613 : template <Endian Endianess>
614 : inline bool operator<= (const BytesViewTemplate<Endianess> &l, const memory::StandartInterface::BytesType &r) {
615 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::less_equal<uint8_t>());
616 : }
617 :
618 :
619 : template <Endian Endianess>
620 : inline bool operator> (const BytesViewTemplate<Endianess> &l, const BytesViewTemplate<Endianess> &r) {
621 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater<uint8_t>());
622 : }
623 :
624 : template <Endian Endianess>
625 : inline bool operator> (const memory::PoolInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
626 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater<uint8_t>());
627 : }
628 :
629 : template <Endian Endianess>
630 : inline bool operator> (const memory::StandartInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
631 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater<uint8_t>());
632 : }
633 :
634 : template <Endian Endianess>
635 : inline bool operator> (const BytesViewTemplate<Endianess> &l, const memory::PoolInterface::BytesType &r) {
636 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater<uint8_t>());
637 : }
638 :
639 : template <Endian Endianess>
640 : inline bool operator> (const BytesViewTemplate<Endianess> &l, const memory::StandartInterface::BytesType &r) {
641 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater<uint8_t>());
642 : }
643 :
644 :
645 : template <Endian Endianess>
646 : inline bool operator>= (const BytesViewTemplate<Endianess> &l, const BytesViewTemplate<Endianess> &r) {
647 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater_equal<uint8_t>());
648 : }
649 :
650 : template <Endian Endianess>
651 : inline bool operator>= (const memory::PoolInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
652 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater_equal<uint8_t>());
653 : }
654 :
655 : template <Endian Endianess>
656 : inline bool operator>= (const memory::StandartInterface::BytesType &l, const BytesViewTemplate<Endianess> &r) {
657 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater_equal<uint8_t>());
658 : }
659 :
660 : template <Endian Endianess>
661 : inline bool operator>= (const BytesViewTemplate<Endianess> &l, const memory::PoolInterface::BytesType &r) {
662 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater_equal<uint8_t>());
663 : }
664 :
665 : template <Endian Endianess>
666 : inline bool operator>= (const BytesViewTemplate<Endianess> &l, const memory::StandartInterface::BytesType &r) {
667 : return std::lexicographical_compare(l.data(), l.data() + l.size(), r.data(), r.data() + r.size(), std::greater_equal<uint8_t>());
668 : }
669 :
670 : }
671 :
672 : #endif /* STAPPLER_CORE_UTILS_SPDATAREADER_H_ */
|
