Embedded Template Library 1.0
Loading...
Searching...
No Matches
flags.h
Go to the documentation of this file.
1
2
3/******************************************************************************
4The MIT License(MIT)
5
6Embedded Template Library.
7https://github.com/ETLCPP/etl
8https://www.etlcpp.com
9
10Copyright(c) 2020 John Wellbelove
11
12Permission is hereby granted, free of charge, to any person obtaining a copy
13of this software and associated documentation files(the "Software"), to deal
14in the Software without restriction, including without limitation the rights
15to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
16copies of the Software, and to permit persons to whom the Software is
17furnished to do so, subject to the following conditions :
18
19The above copyright notice and this permission notice shall be included in all
20copies or substantial portions of the Software.
21
22THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
25AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
28SOFTWARE.
29******************************************************************************/
30
31#ifndef ETL_FLAGS_INCLUDED
32#define ETL_FLAGS_INCLUDED
33
34#include "platform.h"
35#include "algorithm.h"
36#include "type_traits.h"
37#include "integral_limits.h"
38#include "static_assert.h"
39#include "initializer_list.h"
40
41#include <string.h>
42#include <stddef.h>
43#include <stdint.h>
44
45namespace etl
46{
47 //*************************************************************************
50 //*************************************************************************
51 template <typename T, T MASK = etl::integral_limits<T>::max>
52 class flags
53 {
54 public:
55
56 ETL_STATIC_ASSERT(etl::is_integral<T>::value && etl::is_unsigned<T>::value, "Unsigned integral values only");
57
58 typedef T value_type;
59
60 static ETL_CONSTANT value_type ALL_SET = etl::integral_limits<value_type>::max & MASK;
61 static ETL_CONSTANT value_type ALL_CLEAR = 0;
62
63 static ETL_CONSTANT size_t NBITS = etl::integral_limits<value_type>::bits;
64
65 //*************************************************************************
67 //*************************************************************************
68 ETL_CONSTEXPR flags() ETL_NOEXCEPT
69 : data(value_type(0))
70 {
71 }
72
73 ETL_CONSTEXPR flags(value_type pattern) ETL_NOEXCEPT
74 : data(pattern & MASK)
75 {
76 }
77
78 ETL_CONSTEXPR flags(const flags<T, MASK>& pattern) ETL_NOEXCEPT
79 : data(pattern.value())
80 {
81 }
82
83 //*************************************************************************
85 //*************************************************************************
86 template <value_type pattern>
87 ETL_CONSTEXPR bool test() const ETL_NOEXCEPT
88 {
89 return (data & pattern) != value_type(0);
90 }
91
92 //*******************************************
93 ETL_CONSTEXPR bool test(value_type pattern) const ETL_NOEXCEPT
94 {
95 return (data & pattern) != value_type(0);
96 }
97
98 //*************************************************************************
100 //*************************************************************************
101 template <value_type pattern, bool value>
102 ETL_CONSTEXPR14 flags<T, MASK>& set() ETL_NOEXCEPT
103 {
104 value ? data |= (pattern & MASK) : data &= (~pattern & MASK);
105
106 return *this;
107 }
108
109 //*******************************************
110 template <value_type pattern>
111 ETL_CONSTEXPR14 flags<T, MASK>& set(bool value) ETL_NOEXCEPT
112 {
113 value ? data |= (pattern & MASK) : data &= (~pattern & MASK);
114
115 return *this;
116 }
117
118 //*******************************************
119 template <value_type pattern>
120 ETL_CONSTEXPR14 flags<T, MASK>& set() ETL_NOEXCEPT
121 {
122 data |= (pattern & MASK);
123
124 return *this;
125 }
126
127 //*******************************************
128 ETL_CONSTEXPR14 flags<T, MASK>& set(value_type pattern) ETL_NOEXCEPT
129 {
130 data |= (pattern & MASK);
131
132 return *this;
133 }
134
135 //*******************************************
136 ETL_CONSTEXPR14 flags<T, MASK>& set(value_type pattern, bool value) ETL_NOEXCEPT
137 {
138 value ? data |= (pattern & MASK) : data &= (~pattern & MASK);
139
140 return *this;
141 }
142
143 //*************************************************************************
145 //*************************************************************************
146 ETL_CONSTEXPR14 flags<T, MASK>& clear() ETL_NOEXCEPT
147 {
148 data = ALL_CLEAR;
149
150 return *this;
151 }
152
153 //*************************************************************************
155 //*************************************************************************
156 template <value_type pattern>
157 ETL_CONSTEXPR14 flags<T, MASK>& reset() ETL_NOEXCEPT
158 {
159 data &= ~pattern;
160
161 return *this;
162 }
163
164 //*******************************************
165 ETL_CONSTEXPR14 flags<T, MASK>& reset(value_type pattern) ETL_NOEXCEPT
166 {
167 data &= ~pattern;
168
169 return *this;
170 }
171
172 //*************************************************************************
174 //*************************************************************************
175 ETL_CONSTEXPR14 flags<T, MASK>& flip() ETL_NOEXCEPT
176 {
177 data = (~data & MASK);
178
179 return *this;
180 }
181
182 //*******************************************
183 template <value_type pattern>
184 ETL_CONSTEXPR14 flags<T, MASK>& flip() ETL_NOEXCEPT
185 {
186 data ^= pattern & MASK;
187
188 return *this;
189 }
190
191 //*******************************************
192 ETL_CONSTEXPR14 flags<T, MASK>& flip(value_type pattern) ETL_NOEXCEPT
193 {
194 data ^= pattern & MASK;
195
196 return *this;
197 }
198
199 //*************************************************************************
200 // Are all the bits sets?
201 //*************************************************************************
202 ETL_CONSTEXPR bool all() const ETL_NOEXCEPT
203 {
204 return data == MASK;
205 }
206
207 //*******************************************
208 template <value_type pattern>
209 ETL_CONSTEXPR bool all_of() const ETL_NOEXCEPT
210 {
211 return (data & (pattern & MASK)) == (pattern & MASK);
212 }
213
214 //*******************************************
215 ETL_CONSTEXPR bool all_of(value_type pattern) const ETL_NOEXCEPT
216 {
217 return (data & (pattern & MASK)) == (pattern & MASK);
218 }
219
220 //*************************************************************************
222 //*************************************************************************
223 ETL_CONSTEXPR bool none() const ETL_NOEXCEPT
224 {
225 return (data & MASK) == ALL_CLEAR;
226 }
227
228 //*******************************************
229 template <value_type pattern>
230 ETL_CONSTEXPR bool none_of() const ETL_NOEXCEPT
231 {
232 return !any_of(pattern);
233 }
234
235 //*******************************************
236 ETL_CONSTEXPR bool none_of(value_type pattern) const ETL_NOEXCEPT
237 {
238 return !any_of(pattern);
239 }
240
241 //*************************************************************************
243 //*************************************************************************
244 ETL_CONSTEXPR bool any() const ETL_NOEXCEPT
245 {
246 return (data & MASK) != value_type(0);
247 }
248
249 //*******************************************
250 template <value_type pattern>
251 ETL_CONSTEXPR bool any_of() const ETL_NOEXCEPT
252 {
253 return (data & (pattern & MASK)) != value_type(0);
254 }
255
256 //*******************************************
257 ETL_CONSTEXPR bool any_of(value_type pattern) const
258 {
259 return (data & (pattern & MASK)) != value_type(0);
260 }
261
262 //*************************************************************************
264 //*************************************************************************
265 ETL_CONSTEXPR value_type value() const ETL_NOEXCEPT
266 {
267 return data;
268 }
269
270 //*************************************************************************
272 //*************************************************************************
273 ETL_CONSTEXPR14 flags<T, MASK>& value(value_type pattern) ETL_NOEXCEPT
274 {
275 data = pattern & MASK;
276
277 return *this;
278 }
279
280 //*************************************************************************
282 //*************************************************************************
283 ETL_CONSTEXPR operator value_type() const ETL_NOEXCEPT
284 {
285 return data;
286 }
287
288 //*************************************************************************
290 //*************************************************************************
291 ETL_CONSTEXPR14 flags<T, MASK>& operator &=(value_type pattern) ETL_NOEXCEPT
292 {
293 data &= pattern;
294
295 return *this;
296 }
297
298 //*************************************************************************
300 //*************************************************************************
301 ETL_CONSTEXPR14 flags<T, MASK>& operator |=(value_type pattern) ETL_NOEXCEPT
302 {
303 data |= (pattern & MASK);
304
305 return *this;
306 }
307
308 //*************************************************************************
310 //*************************************************************************
311 ETL_CONSTEXPR14 flags<T, MASK>& operator ^=(value_type pattern) ETL_NOEXCEPT
312 {
313 data ^= (pattern & MASK);
314
315 return *this;
316 }
317
318 //*************************************************************************
320 //*************************************************************************
321 ETL_CONSTEXPR14 flags<T, MASK>& operator =(flags<T, MASK> other) ETL_NOEXCEPT
322 {
323 data = other.data;
324
325 return *this;
326 }
327
328 //*************************************************************************
330 //*************************************************************************
331 ETL_CONSTEXPR14 flags<T, MASK>& operator =(value_type pattern) ETL_NOEXCEPT
332 {
333 data = (pattern & MASK);
334
335 return *this;
336 }
337
338 //*************************************************************************
340 //*************************************************************************
341 void swap(flags<T, MASK>& other) ETL_NOEXCEPT
342 {
343 using ETL_OR_STD::swap;
344 swap(data, other.data);
345 }
346
347 private:
348
349 value_type data;
350 };
351
352 template <typename T, T MASK>
353 ETL_CONSTANT typename flags<T, MASK>::value_type flags<T, MASK>::ALL_SET;
354
355 template <typename T, T MASK>
356 ETL_CONSTANT typename flags<T, MASK>::value_type flags<T, MASK>::ALL_CLEAR;
357
358 template <typename T, T MASK>
359 ETL_CONSTANT size_t flags<T, MASK>::NBITS;
360
361 //***************************************************************************
363 //***************************************************************************
364 template <typename T, T MASK>
365 ETL_CONSTEXPR bool operator == (flags<T, MASK> lhs, flags<T, MASK> rhs) ETL_NOEXCEPT
366 {
367 return lhs.value() == rhs.value();
368 }
369
370 //***************************************************************************
372 //***************************************************************************
373 template <typename T, T MASK>
374 ETL_CONSTEXPR bool operator != (flags<T, MASK> lhs, flags<T, MASK> rhs) ETL_NOEXCEPT
375 {
376 return !(lhs == rhs);
377 }
378
379 //*************************************************************************
381 //*************************************************************************
382 template <typename T, T MASK>
384 {
385 lhs.swap(rhs);
386 }
387}
388
389#endif
Definition flags.h:53
ETL_CONSTEXPR14 flags< T, MASK > & set() ETL_NOEXCEPT
Set the bits.
Definition flags.h:102
ETL_CONSTEXPR14 flags< T, MASK > & operator^=(value_type pattern) ETL_NOEXCEPT
operator ^=
Definition flags.h:311
ETL_CONSTEXPR14 flags< T, MASK > & clear() ETL_NOEXCEPT
Clear all of the flags.
Definition flags.h:146
ETL_CONSTEXPR14 flags< T, MASK > & operator|=(value_type pattern) ETL_NOEXCEPT
operator |=
Definition flags.h:301
ETL_CONSTEXPR flags() ETL_NOEXCEPT
Constructor.
Definition flags.h:68
ETL_CONSTEXPR14 flags< T, MASK > & flip() ETL_NOEXCEPT
Flip bits.
Definition flags.h:175
ETL_CONSTEXPR14 flags< T, MASK > & reset() ETL_NOEXCEPT
Reset the bit at the pattern.
Definition flags.h:157
ETL_CONSTEXPR14 flags< T, MASK > & value(value_type pattern) ETL_NOEXCEPT
Set the value of the flags.
Definition flags.h:273
ETL_CONSTEXPR14 flags< T, MASK > & operator&=(value_type pattern) ETL_NOEXCEPT
operator &=
Definition flags.h:291
ETL_CONSTEXPR bool none() const ETL_NOEXCEPT
Are none of the bits set?
Definition flags.h:223
ETL_CONSTEXPR bool any() const ETL_NOEXCEPT
Are any of the bits set?
Definition flags.h:244
void swap(flags< T, MASK > &other) ETL_NOEXCEPT
swap
Definition flags.h:341
ETL_CONSTEXPR bool test() const ETL_NOEXCEPT
Tests bits.
Definition flags.h:87
ETL_CONSTEXPR value_type value() const ETL_NOEXCEPT
Return the value of the flags.
Definition flags.h:265
ETL_CONSTEXPR14 flags< T, MASK > & operator=(flags< T, MASK > other) ETL_NOEXCEPT
operator =
Definition flags.h:321
Definition integral_limits.h:516
is_integral
Definition type_traits_generator.h:996
is_unsigned
Definition type_traits_generator.h:1016
bitset_ext
Definition absolute.h:38
bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:654
void swap(etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
Template deduction guides.
Definition array.h:630
bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:642
pair holds two objects of arbitrary type
Definition utility.h:164