enumeratedarray.h

Go to the documentation of this file.

 
#pragma once
 
#include <config.h>
 
#include <cassert>
 
#include <type_traits>
 
template <typename Enumeration, typename ValueType,
          Enumeration size_element = Enumeration::Count,
          int enum_size = static_cast <int> (size_element)>
class EnumeratedArray {
    using needs_initialization = std::conditional <std::is_pod<ValueType>::value,std::true_type,std::false_type>;
    ValueType underlying [enum_size];
public:
    using value_type = ValueType;
    using enumeration_type = Enumeration;
    EnumeratedArray () {
        /* If the value type is a class, it will initialize itself.  Use template
           magic to avoid reinitializing it, but do initialize other data types. */
        if (needs_initialization::type::value) {
            for (int i = 0; i < enum_size; i++) {
                underlying [i] = ValueType {};
            }
        }
    }
    explicit EnumeratedArray (ValueType initial) {
        for (int i = 0; i < enum_size; i++) {
            underlying [i] = initial;
        }
    }
    inline ValueType &operator[] (const Enumeration index) noexcept {
        assert (static_cast <int> (index) >= 0 && static_cast <int> (index) < enum_size);
        return underlying [static_cast <const int> (index)];
    }
    inline const ValueType &operator[] (const Enumeration index) const noexcept {
        assert (static_cast <int> (index) >= 0 && static_cast <int> (index) < enum_size);
        return underlying [static_cast <const int> (index)];
    }
 
    template <class IteratedType>
    class eaiterator {
        friend class EnumeratedArray;
        IteratedType *start = nullptr;
        IteratedType *item = nullptr;
    public:
        inline eaiterator (IteratedType *s, IteratedType *i) noexcept: start (s), item (i) {};
    public:
        eaiterator() noexcept = default;
        eaiterator (const eaiterator<IteratedType> &) noexcept = default;
        eaiterator &operator=(const eaiterator<IteratedType> &) noexcept = default;
        inline IteratedType &operator*() const noexcept {
            assert (item);
            return *item;
        }
        inline IteratedType *operator->() const noexcept {
            assert (item);
            return item;
        }
        inline eaiterator<IteratedType> &operator++ () noexcept {
            assert (item);
            item++;
            return *this;
        }
        inline eaiterator<IteratedType> operator++ (int) noexcept {
            assert (item);
            eaiterator<IteratedType> prior = *this;
            item++;
            return prior;
        }
        inline bool operator!=(const eaiterator<IteratedType> &compare) const noexcept {
            assert (item);
            return item != compare.item;
        }
        inline bool operator==(const eaiterator<IteratedType> &compare) const noexcept {
            assert (item);
            return item == compare.item;
        }
        inline Enumeration key() const noexcept {
            return static_cast <Enumeration> (item - start);
        }
    };
    using iterator = eaiterator<ValueType>;
    using const_iterator = eaiterator <const ValueType>;
    
    inline iterator begin () noexcept {
        return iterator (underlying, &underlying [0]);
    }
    inline iterator end () noexcept {
        return iterator (underlying, &underlying [enum_size]);
    }
 
    inline const_iterator begin () const noexcept {
        return const_iterator (&underlying [0], &underlying [0]);
    }
    inline const_iterator end () const noexcept {
        return const_iterator (&underlying [0], &underlying [enum_size]);
    }
};