FlagSet.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_UTILITIES_FLAGSET_H
#define LARDATAOBJ_UTILITIES_FLAGSET_H

// LArSoft headers

#include "lardataobj/Utilities/BitMask.h"

// C/C++ standard library
#include <iosfwd> // std::ostream
#include <string>
#include <exception>

namespace util {
  
  namespace flags {
    
    template
      <unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>
    class FlagSet: public BitMask<Storage> {
      
      static_assert(details::computePages<Storage>(NFlags) <= 1,
        "Too many flags for this storage type.");
      
        public:
      using This_t = FlagSet<NFlags, Storage>; 
      
      using Mask_t = BitMask<Storage>; 
      
      using Base_t = Mask_t; 
      
      using Bits_t = typename Mask_t::Bits_t;
      
      using FlagIndex_t = typename Mask_t::FlagIndex_t;
      
      using Flag_t = typename Mask_t::Flag_t;
      
      
      
      using Exception = typename Mask_t::Exception;
      
      using OutOfRangeError = typename Mask_t::OutOfRangeError;
      
      using FlagNotDefinedError = typename Mask_t::FlagNotDefinedError;
      
      
      
      FlagSet() = default;
      FlagSet(This_t const&) = default;
      FlagSet(This_t&&) = default;
      FlagSet& operator= (This_t const&) = default;
      FlagSet& operator= (This_t&&) = default;
      
      // This is effectively a copy constructor due to the definition of Mask_t.
      constexpr FlagSet(Mask_t const& from): Base_t(from) {}
      
      
      using Base_t::Base_t; // inherit the rest of the constructors
      
      
      
      
      constexpr Mask_t const& mask() const { return *this; }
      
      constexpr bool isFlag(FlagIndex_t flagIndex) const;
      
      constexpr bool isFlag(Flag_t flag) const;
      
      
      bool test(Flag_t flag) const;
      
      bool test(FlagIndex_t flagIndex) const;
      
      
      
      template <typename Stream>
      void dump(Stream&& out) const
        { mask().dump(std::forward<Stream>(out), size()); }
      
      
      static constexpr size_t size()
        { return NFlags; }
      
      
      template <typename... Args>
      static constexpr Mask_t createMask(Args... args)
        { return Mask_t::create(args...); }
      
        private:
      
      bool testImpl(Flag_t flag) const;
      
    }; // class FlagSet<>
    
    
    template <unsigned int NBits, typename Storage>
    std::ostream& operator<<
      (std::ostream& out, FlagSet<NBits, Storage> const& flags)
      { flags.dump(out); return out; }
    
  } // namespace flags
  
} // namespace util


//------------------------------------------------------------------------------
//---  template implementation
//---  

#include "FlagSet.tcc"

//------------------------------------------------------------------------------


#endif // LARDATAOBJ_UTILITIES_FLAGSET_H