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 <exception>
#include <iosfwd> // std::ostream
#include <string>

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