enums.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_BASE_ENUMS_H
#define ELEMENTA_BASE_ENUMS_H
 
#include <stdexcept>
#include <string>
#include <vector>
#include <bitset>
#include <initializer_list>
#include <type_traits>
#include "elementa/base/strings.h"
 
 
namespace elementa
{
 
namespace base
{
 
/* ***************************************************************************
 
    Template class: EnumExtPriv
    Template subclass: EnumExtPriv::Combination
 
*****************************************************************************/
 
 
template <typename BaseID, class HelperIDString>
class EnumExtPriv final
{
 public:
 
    using IDBase = BaseID;
 
    class Combination 
    {
      public:
 
        class Iterator 
        {
         public:
 
 
             Iterator(const Combination & c, bool end = false) noexcept: 
                comb_{c} 
             { if (end) v_ = EnumExtPriv::kValue(BaseID::kAll_);
               else 
               {
                    typename std::underlying_type<BaseID>::type f;
                    for (f=0; f<EnumExtPriv::kValue(BaseID::kAll_); f++)
                        if (comb_.has(EnumExtPriv::id(f))) break;
                    v_ = f;
               }
             } 
 
             // Destructor (non virtual), copies and moves by default.
 
             BaseID operator*(void) const // may throw
                { return(EnumExtPriv::id(v_)); }
 
             Iterator & operator++(void) noexcept // may throw
                { while (v_ < EnumExtPriv::kValue(BaseID::kAll_))
                  { ++v_; if (v_ == EnumExtPriv::kValue(BaseID::kAll_)) break;
                    if (comb_.has(EnumExtPriv::id(v_))) break; }
                  return(*this); }
 
             Iterator operator++(int) noexcept
                { Iterator old{*this}; this->operator++(); return(old); }
 
             bool operator!=(const Iterator &o) const noexcept
                { return((v_ != o.v_) || (comb_ != o.comb_)); }
 
             bool operator==(const Iterator &o) const noexcept
                { return((v_ == o.v_) && (comb_ == o.comb_)); }
 
         private:
 
             const Combination & comb_;
             typename std::underlying_type<BaseID>::type v_;
        };
 
 
        using Initializer = std::initializer_list<BaseID>;
 
        Combination(void) = default;
        ~Combination(void) = default; 
 
        Combination(const Combination & tf) = default;
        Combination & operator=(const Combination & tf) = default;
 
        Combination(Combination &&) = default;
        Combination & operator=(Combination &&) = default;
        
 
        explicit Combination(BaseID f) // constructor from one or all flags
            { activate(BaseID::kAll_); }
 
 
        Combination(const Initializer & init)  
            { for (BaseID f: init) { add(f); if (f==BaseID::kAll_) break;} }
 
        bool operator!=(const Combination &o) const noexcept
            { return(bset_ != o.bset_); }
        bool operator==(const Combination &o) const noexcept
            { return(bset_ == o.bset_); }
 
        size_t size(void) const noexcept
            { return(bset_.count()); }
            
        bool empty(void) const noexcept 
            { return(bset_.count() == 0); }
 
        bool any(void) const 
            { return(bset_.any()); }
 
        bool all(void) const 
            { return(bset_.all()); }
 
        bool has(BaseID f) const
            { if (f==BaseID::kAll_) return(all());
              else return(bset_.test(EnumExtPriv::kValue(f))); }
        bool has(const Combination & otf) const 
            { return((bset_ & otf.bset_) == otf.bset_); }
 
        bool hasIntersection(const Combination & otf) const
            { return((bset_ & otf.bset_).any()); }
 
        void add(BaseID f) 
            { if (f==BaseID::kAll_) bset_.set();
              else bset_.set(EnumExtPriv::kValue(f)); }
        void add(const Combination & tf)
            { bset_ |= tf.bset_; }
 
        void remove(BaseID f) 
            { if (f==BaseID::kAll_) bset_.reset();
              else bset_.reset(EnumExtPriv::kValue(f)); }
        void remove(const Combination & tf) 
            { bset_ &= tf.bset_; }
 
        std::string to_string(std::string delim=", ") const noexcept
            { std::string res; 
              size_t c = size();
              if (c > 0)
                for (auto id: *this) 
                { res += EnumExtPriv::IdName(id); c--; if (c>0) res += delim; }
              return(res); }
 
        Iterator begin(void) const noexcept
            { return(Iterator(*this)); }
 
        Iterator end(void) const noexcept
            { return(Iterator(*this,true)); }
 
      private:
 
        std::bitset< EnumExtPriv::kValue(BaseID::kAll_) > bset_{}; 
        // bitset has no iterator in C++11, does it would not be of any benefit
        // to expose this member
    };
 
    class Iterator 
    {
     public:
 
         Iterator(BaseID val = static_cast<BaseID>(0)) noexcept: 
            v_(EnumExtPriv::kValue(val)) 
            {} // subclasses can access protected and private members of parent
 
         // Destructor (non virtual), moves and copies by default.
 
         BaseID operator*(void) const // may throw
            { return(EnumExtPriv::id(v_)); }
 
         Iterator & operator++(void) noexcept
            { if (v_ < EnumExtPriv::kValue(BaseID::kAll_)) v_++; return(*this);}
 
         Iterator operator++(int) noexcept
            { Iterator old = *this; this->operator++(); return(old); }
 
         bool operator!=(const Iterator &o) const noexcept
            { return(v_ != o.v_); }
 
         bool operator==(const Iterator &o) const noexcept
            { return(v_ == o.v_); }
 
     private:
 
         typename std::underlying_type<BaseID>::type v_;
    };
 
    static constexpr size_t kSize(void) noexcept
        { return(static_cast<size_t>(EnumExtPriv::kValue(BaseID::kAll_))); }
        
    static BaseID first(void) { return(id(0)); }
 
    static BaseID last(void) 
        { return(id(EnumExtPriv::kValue(BaseID::kAll_) - 1)); }
        
#if (ELE_PRE_CPPVER != 2011) && (ELE_PRE_CPPVER != 2014)
    static constexpr BaseID Nth(size_t n) 
#else
    static BaseID Nth(size_t n) 
#endif
        { return(id(static_cast<typename std::underlying_type<BaseID>::type>(
            n))); }
    
    static constexpr size_t pos(BaseID id) { return(kValue(id)); }
    
 
    static BaseID findByName(const std::string & name)
    {
        auto res = BaseID::kAll_;
        if (!name.empty())
            for (auto m: theEnum()) if (IdName(m) == name) { res = m; break; }
        return(res);
    }
 
 
    static std::string IdName(BaseID id, bool leavek = false) 
    { static std::vector<std::string> strs;
      static int status{0}; 
      static std::string nullstr;
 
        if (id == BaseID::kAll_) return("<All>");
        if (status==0) // only do this work once
        {
            strs = std::move(split(std::string{HelperIDString::IdNames()},','));
            if (static_cast<size_t>(strs.size()) != 
                static_cast<size_t>(EnumExtPriv::kValue(BaseID::kAll_))) 
                status = -1;
            status = 1;
        }
        size_t ind = EnumExtPriv::kValue(id);
        if ((status != 1) || (ind >= strs.size())) return("<enum-error>");
        const auto & res = strs[EnumExtPriv::kValue(id)];
        if (leavek || (res.size() < 2) || 
            (res[0] != 'k') || (res[1] < 'A') || (res[1] > 'Z')) return(res);
        return(res.substr(1));
    }
 
 
    static constexpr std::string kAllIdNames(void) noexcept
        { return(HelperIDString::IdNames()); }
 
 
    static EnumExtPriv & theEnum(void) noexcept
        { static EnumExtPriv ie; return(ie); }
 
    // The following cannot be static since they work on an object
 
    Iterator begin(void) const noexcept
        { return(Iterator()); }
 
    Iterator end(void) const noexcept
        { return(Iterator(BaseID::kAll_)); }
 
 private:
 
    // Not public for avoiding abuse of enum IDs like numbers
    // (use iterations instead).
 
    static constexpr typename std::underlying_type<BaseID>::type 
        kValue(BaseID id) noexcept // implicitly inline
            { return(
                static_cast<typename std::underlying_type<BaseID>::type>(id)); }
 
#if (ELE_PRE_CPPVER != 2011) && (ELE_PRE_CPPVER != 2014)
    static constexpr BaseID id(typename std::underlying_type<BaseID>::type v) 
#else
    // cannot be constexpr for its structure
    static BaseID id(typename std::underlying_type<BaseID>::type v) 
#endif
        { if (v >= EnumExtPriv::kValue(BaseID::kAll_))
            throw(std::out_of_range(""));
          return(static_cast<BaseID>(v)); }
 
    EnumExtPriv(void) = default;
    // move implicitly declared
    // destructor implicitly declared (non virtual)
    // copies implictly declared
 
};
 
 
/* ***************************************************************************
 
    Macro: ELE_CLASS_ENUM
 
*****************************************************************************/
 
 
#define ELE_CLASS_ENUM(NameEnumClass,...) \
    enum class NameEnumClass { __VA_ARGS__ , kAll_ }; \
    struct NameEnumClass##HelperIDString \
    { \
        static const char * IdNames(void) noexcept \
            { return(#__VA_ARGS__); } \
    }; \
    using NameEnumClass##Enum = elementa::base::EnumExtPriv<\
                                                NameEnumClass, \
                                                NameEnumClass##HelperIDString>
 
 
 // Enums
 
 
} // end namespace base
 
} // end namespace elementa
 
#endif