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