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) : 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 //---------------------------------------------------------------------- 57 Flags (const Flags& rhs) : 58 m_flags(rhs.m_flags) 59 { 60 } 61 62 //---------------------------------------------------------------------- 63 /// Destructor. 64 //---------------------------------------------------------------------- 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 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 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 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 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 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 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 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 187 AllClear (ValueType mask) const 188 { 189 return (m_flags & mask) == 0; 190 } 191 192 bool 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 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 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 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
