1 //===-- Flags.h -------------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef liblldb_Flags_h_
11 #define liblldb_Flags_h_
12 #if defined(__cplusplus)
13 
14 
15 #include <stdint.h>
16 #include <unistd.h>
17 
18 namespace lldb_private {
19 
20 //----------------------------------------------------------------------
21 /// @class Flags Flags.h "lldb/Core/Flags.h"
22 /// @brief A class to manage flags.
23 ///
24 /// The Flags class managed flag bits and allows testing and
25 /// modification of individual or multiple flag bits.
26 //----------------------------------------------------------------------
27 class Flags
28 {
29 public:
30     //----------------------------------------------------------------------
31     /// The value type for flags is a 32 bit unsigned integer type.
32     //----------------------------------------------------------------------
33     typedef uint32_t ValueType;
34 
35     //----------------------------------------------------------------------
36     /// Construct with initial flag bit values.
37     ///
38     /// Constructs this object with \a mask as the initial value for all
39     /// of the flags.
40     ///
41     /// @param[in] mask
42     ///     The initial value for all flags.
43     //----------------------------------------------------------------------
44     Flags (ValueType flags = 0) :
m_flags(flags)45         m_flags (flags)
46     {
47     }
48 
49     //----------------------------------------------------------------------
50     /// Copy constructor.
51     ///
52     /// Construct and copy the flags from \a rhs.
53     ///
54     /// @param[in] rhs
55     ///     A const Flags object reference to copy.
56     //----------------------------------------------------------------------
Flags(const Flags & rhs)57     Flags (const Flags& rhs) :
58         m_flags(rhs.m_flags)
59     {
60     }
61 
62     //----------------------------------------------------------------------
63     /// Destructor.
64     //----------------------------------------------------------------------
~Flags()65     ~Flags ()
66     {
67     }
68 
69     //----------------------------------------------------------------------
70     /// Get accessor for all flags.
71     ///
72     /// @return
73     ///     Returns all of the flags as a Flags::ValueType.
74     //----------------------------------------------------------------------
75     ValueType
Get()76     Get () const
77     {
78         return m_flags;
79     }
80 
81     //----------------------------------------------------------------------
82     /// Return the number of flags that can be represented in this
83     /// object.
84     ///
85     /// @return
86     ///     The maximum number bits in this flag object.
87     //----------------------------------------------------------------------
88     size_t
GetBitSize()89     GetBitSize() const
90     {
91         return sizeof (ValueType) * 8;
92     }
93 
94     //----------------------------------------------------------------------
95     /// Set accessor for all flags.
96     ///
97     /// @param[in] flags
98     ///     The bits with which to replace all of the current flags.
99     //----------------------------------------------------------------------
100     void
Reset(ValueType flags)101     Reset (ValueType flags)
102     {
103         m_flags = flags;
104     }
105 
106     //----------------------------------------------------------------------
107     /// Clear one or more flags.
108     ///
109     /// @param[in] mask
110     ///     A bitfield containing one or more flags.
111     ///
112     /// @return
113     ///     The new flags after clearing all bits from \a mask.
114     //----------------------------------------------------------------------
115     ValueType
116     Clear (ValueType mask = ~(ValueType)0)
117     {
118         m_flags &= ~mask;
119         return m_flags;
120     }
121 
122 
123     //----------------------------------------------------------------------
124     /// Set one or more flags by logical OR'ing \a mask with the current
125     /// flags.
126     ///
127     /// @param[in] mask
128     ///     A bitfield containing one or more flags.
129     ///
130     /// @return
131     ///     The new flags after setting all bits from \a mask.
132     //----------------------------------------------------------------------
133     ValueType
Set(ValueType mask)134     Set (ValueType mask)
135     {
136         m_flags |= mask;
137         return m_flags;
138     }
139 
140 
141     //----------------------------------------------------------------------
142     /// Test if all bits in \a mask are 1 in the current flags
143     ///
144     /// @return
145     ///     \b true if all flags in \a mask are 1, \b false
146     ///     otherwise.
147     //----------------------------------------------------------------------
148     bool
AllSet(ValueType mask)149     AllSet (ValueType mask) const
150     {
151         return (m_flags & mask) == mask;
152     }
153 
154     //----------------------------------------------------------------------
155     /// Test one or more flags.
156     ///
157     /// @return
158     ///     \b true if any flags in \a mask are 1, \b false
159     ///     otherwise.
160     //----------------------------------------------------------------------
161     bool
AnySet(ValueType mask)162     AnySet (ValueType mask) const
163     {
164         return (m_flags & mask) != 0;
165     }
166 
167     //----------------------------------------------------------------------
168     /// Test a single flag bit.
169     ///
170     /// @return
171     ///     \b true if \a bit is set, \b false otherwise.
172     //----------------------------------------------------------------------
173     bool
Test(ValueType bit)174     Test (ValueType bit) const
175     {
176         return (m_flags & bit) != 0;
177     }
178 
179     //----------------------------------------------------------------------
180     /// Test if all bits in \a mask are clear.
181     ///
182     /// @return
183     ///     \b true if \b all flags in \a mask are clear, \b false
184     ///     otherwise.
185     //----------------------------------------------------------------------
186     bool
AllClear(ValueType mask)187     AllClear (ValueType mask) const
188     {
189         return (m_flags & mask) == 0;
190     }
191 
192     bool
AnyClear(ValueType mask)193     AnyClear (ValueType mask) const
194     {
195         return (m_flags & mask) != mask;
196     }
197 
198     //----------------------------------------------------------------------
199     /// Test a single flag bit to see if it is clear (zero).
200     ///
201     /// @return
202     ///     \b true if \a bit is 0, \b false otherwise.
203     //----------------------------------------------------------------------
204     bool
IsClear(ValueType bit)205     IsClear (ValueType bit) const
206     {
207         return (m_flags & bit) == 0;
208     }
209 
210     //----------------------------------------------------------------------
211     /// Get the number of zero bits in \a m_flags.
212     ///
213     /// @return
214     ///     The number of bits that are set to 0 in the current flags.
215     //----------------------------------------------------------------------
216     size_t
ClearCount()217     ClearCount () const
218     {
219         size_t count = 0;
220         for (ValueType shift = 0; shift < sizeof(ValueType)*8; ++shift)
221         {
222             if ((m_flags & (1u << shift)) == 0)
223                 ++count;
224         }
225         return count;
226     }
227 
228     //----------------------------------------------------------------------
229     /// Get the number of one bits in \a m_flags.
230     ///
231     /// @return
232     ///     The number of bits that are set to 1 in the current flags.
233     //----------------------------------------------------------------------
234     size_t
SetCount()235     SetCount () const
236     {
237         size_t count = 0;
238         for (ValueType mask = m_flags; mask; mask >>= 1)
239         {
240             if (mask & 1u)
241                 ++count;
242         }
243         return count;
244     }
245 
246 protected:
247     ValueType   m_flags;    ///< The flags.
248 };
249 
250 } // namespace lldb_private
251 
252 #endif  // #if defined(__cplusplus)
253 #endif  // liblldb_Flags_h_
254