Flags.h

Go to the documentation of this file.

#pragma once

// -- std header
#include <bitset>

namespace marlinmt {
  namespace book {

    class Flag_t ;
    namespace Flags {
      constexpr unsigned long long value( const Flag_t &flag ) ;
    } // end namespace Flags

    class Flag_t {
      static constexpr std::size_t AmtFlags = 8 ;

    public:
      explicit constexpr Flag_t( unsigned long long val )
        : _val{val}, _initValue{val} {}

      explicit Flag_t( const std::bitset< AmtFlags > &val ) : _val{val} {}

      Flag_t operator~() const {
        return Flag_t(~_val);
      }

      Flag_t operator&( const Flag_t &f ) const {
        return Flag_t( _val & f._val ) ;
      }

      Flag_t operator|( const Flag_t &f ) const {
        return Flag_t( _val | f._val ) ;
      }

      explicit operator bool() const { return _val.any(); }

      explicit operator const std::bitset< AmtFlags > &() const { return _val; }

      bool operator==( const Flag_t &f ) const { return _val == f._val; }

      bool operator!=( const Flag_t &f ) const { return _val != f._val; }

      [[nodiscard]] bool contains( const Flag_t &f ) const {
        return ( _val & f._val ) == f._val ;
      }

      explicit operator unsigned long long() const { return _val.to_ullong(); }
      Flag_t()                 = default ;
      Flag_t( const Flag_t & ) = default ;
      Flag_t &operator=( const Flag_t &flag ) {
        _val = flag._val ;
        return *this ;
      }
      Flag_t( Flag_t && ) noexcept = default ;
      Flag_t &operator=( Flag_t &&flag ) noexcept {
        _val = flag._val ;
        return *this ;
      }
      ~Flag_t() = default ;

    private:
      std::bitset< AmtFlags >  _val{0} ;
      const unsigned long long _initValue{0} ;
      friend constexpr unsigned long long
      Flags::value( const Flag_t & /*flag*/ ) ;
    } ;


    namespace Flags {
      constexpr unsigned long long value( const Flag_t &flag ) {
        return flag._initValue ;
      }
      namespace Book {
        constexpr Flag_t Default( 0 ) ;
        constexpr Flag_t Single( 1U << 0U ) ;
        constexpr Flag_t MultiShared( 1U << 1U ) ;
        constexpr Flag_t MultiCopy( 1U << 2U ) ;
        constexpr Flag_t Store( 1U << 3U ) ;
      } // end namespace Book

    } // end namespace Flags

    namespace Masks {
      namespace Book {
        constexpr Flag_t MemoryLayout (
          Flags::value(Flags::Book::Single)
          | Flags::value(Flags::Book::MultiShared)
          | Flags::value(Flags::Book::MultiCopy)) ; 

        constexpr Flag_t StoreOptions(
          Flags::Book::Store) ;
      } // end namespace Book
      
    } // end namespace Masks

  } // end namespace book
} // end namespace marlinmt