//===-- Flags.h -------------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef liblldb_Flags_h_ #define liblldb_Flags_h_ #if defined(__cplusplus) #include <stdint.h> #include <unistd.h> namespace lldb_private { //---------------------------------------------------------------------- /// @class Flags Flags.h "lldb/Core/Flags.h" /// @brief A class to manage flags. /// /// The Flags class managed flag bits and allows testing and /// modification of individual or multiple flag bits. //---------------------------------------------------------------------- class Flags { public: //---------------------------------------------------------------------- /// The value type for flags is a 32 bit unsigned integer type. //---------------------------------------------------------------------- typedef uint32_t ValueType; //---------------------------------------------------------------------- /// Construct with initial flag bit values. /// /// Constructs this object with \a mask as the initial value for all /// of the flags. /// /// @param[in] mask /// The initial value for all flags. //---------------------------------------------------------------------- Flags (ValueType flags = 0) : m_flags (flags) { } //---------------------------------------------------------------------- /// Copy constructor. /// /// Construct and copy the flags from \a rhs. /// /// @param[in] rhs /// A const Flags object reference to copy. //---------------------------------------------------------------------- Flags (const Flags& rhs) : m_flags(rhs.m_flags) { } //---------------------------------------------------------------------- /// Destructor. /// /// The destructor is virtual in case this class is subclassed. //---------------------------------------------------------------------- virtual ~Flags () { } //---------------------------------------------------------------------- /// Get accessor for all flags. /// /// @return /// Returns all of the flags as a Flags::ValueType. //---------------------------------------------------------------------- ValueType Get () const { return m_flags; } //---------------------------------------------------------------------- /// Return the number of flags that can be represented in this /// object. /// /// @return /// The maximum number bits in this flag object. //---------------------------------------------------------------------- size_t GetBitSize() const { return sizeof (ValueType) * 8; } //---------------------------------------------------------------------- /// Set accessor for all flags. /// /// @param[in] flags /// The bits with which to replace all of the current flags. //---------------------------------------------------------------------- void Reset (ValueType flags) { m_flags = flags; } //---------------------------------------------------------------------- /// Clear one or more flags. /// /// @param[in] mask /// A bitfield containing one or more flags. /// /// @return /// The new flags after clearing all bits from \a mask. //---------------------------------------------------------------------- ValueType Clear (ValueType mask = ~(ValueType)0) { m_flags &= ~mask; return m_flags; } //---------------------------------------------------------------------- /// Set one or more flags by logical OR'ing \a mask with the current /// flags. /// /// @param[in] mask /// A bitfield containing one or more flags. /// /// @return /// The new flags after setting all bits from \a mask. //---------------------------------------------------------------------- ValueType Set (ValueType mask) { m_flags |= mask; return m_flags; } //---------------------------------------------------------------------- /// Test if all bits in \a mask are 1 in the current flags /// /// @return /// \b true if all flags in \a mask are 1, \b false /// otherwise. //---------------------------------------------------------------------- bool AllSet (ValueType mask) const { return (m_flags & mask) == mask; } //---------------------------------------------------------------------- /// Test one or more flags. /// /// @return /// \b true if any flags in \a mask are 1, \b false /// otherwise. //---------------------------------------------------------------------- bool AnySet (ValueType mask) const { return (m_flags & mask) != 0; } //---------------------------------------------------------------------- /// Test a single flag bit. /// /// @return /// \b true if \a bit is set, \b false otherwise. //---------------------------------------------------------------------- bool Test (ValueType bit) const { return (m_flags & bit) != 0; } //---------------------------------------------------------------------- /// Test if all bits in \a mask are clear. /// /// @return /// \b true if \b all flags in \a mask are clear, \b false /// otherwise. //---------------------------------------------------------------------- bool AllClear (ValueType mask) const { return (m_flags & mask) == 0; } bool AnyClear (ValueType mask) const { return (m_flags & mask) != mask; } //---------------------------------------------------------------------- /// Test a single flag bit to see if it is clear (zero). /// /// @return /// \b true if \a bit is 0, \b false otherwise. //---------------------------------------------------------------------- bool IsClear (ValueType bit) const { return (m_flags & bit) == 0; } //---------------------------------------------------------------------- /// Get the number of zero bits in \a m_flags. /// /// @return /// The number of bits that are set to 0 in the current flags. //---------------------------------------------------------------------- size_t ClearCount () const { size_t count = 0; for (ValueType shift = 0; shift < sizeof(ValueType)*8; ++shift) { if ((m_flags & (1u << shift)) == 0) ++count; } return count; } //---------------------------------------------------------------------- /// Get the number of one bits in \a m_flags. /// /// @return /// The number of bits that are set to 1 in the current flags. //---------------------------------------------------------------------- size_t SetCount () const { size_t count = 0; for (ValueType mask = m_flags; mask; mask >>= 1) { if (mask & 1u) ++count; } return count; } protected: ValueType m_flags; ///< The flags. }; } // namespace lldb_private #endif // #if defined(__cplusplus) #endif // liblldb_Flags_h_