ContiguousEntityContainer.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/exceptions.h"
#include "catapult/types.h"
 
namespace catapult { namespace model {
 
    enum class EntityContainerErrorPolicy {
        Throw,
 
        Suppress
    };
 
    template<typename TEntity>
    class BasicContiguousEntityContainer final {
    public:
        using value_type = TEntity;
 
    public:
        constexpr BasicContiguousEntityContainer(TEntity* pEntity, size_t entitiesSize, EntityContainerErrorPolicy errorPolicy)
                : m_pStart(pEntity)
                , m_state(entitiesSize, EntityContainerErrorPolicy::Throw == errorPolicy)
        {}
 
    private:
        struct State {
        public:
            const size_t Size;
            const bool ThrowOnError;
            bool HasError;
 
        public:
            constexpr State(size_t size, bool throwOnError)
                    : Size(size)
                    , ThrowOnError(throwOnError)
                    , HasError(false)
            {}
        };
 
    public:
        template<typename TIteratorEntity>
        class iterator {
        public:
            using difference_type = std::ptrdiff_t;
            using value_type = TIteratorEntity;
            using pointer = TIteratorEntity*;
            using reference = TIteratorEntity&;
            using iterator_category = std::forward_iterator_tag;
 
        private:
            template<typename T>
            static constexpr auto ToBytePointer(T* pEntity) {
                return reinterpret_cast<uint8_t*>(pEntity);
            }
 
            template<typename T>
            static constexpr auto ToBytePointer(const T* pEntity) {
                return reinterpret_cast<const uint8_t*>(pEntity);
            }
 
            static constexpr auto Advance(value_type* pEntity, size_t numBytes) {
                return reinterpret_cast<value_type*>(ToBytePointer(pEntity) + numBytes);
            }
 
        public:
            iterator(value_type* pStart, value_type* pCurrent, State& state)
                    : m_pStart(pStart)
                    , m_pCurrent(pCurrent ? pCurrent : Advance(m_pStart, state.Size))
                    , m_state(state) {
                checkError();
            }
 
        public:
            bool operator==(const iterator& rhs) const {
                return m_pStart == rhs.m_pStart && m_state.Size == rhs.m_state.Size && m_pCurrent == rhs.m_pCurrent;
            }
 
            bool operator!=(const iterator& rhs) const {
                return !(*this == rhs);
            }
 
        public:
            iterator& operator++() {
                if (isEnd(m_pCurrent))
                    CATAPULT_THROW_OUT_OF_RANGE("cannot advance iterator beyond end");
 
                m_pCurrent = Advance(m_pCurrent, m_pCurrent->Size);
                if (isEnd(m_pCurrent))
                    return *this;
 
                checkError();
                return *this;
            }
 
            iterator operator++(int) {
                auto copy = *this;
                ++*this;
                return copy;
            }
 
        public:
            reference operator*() const {
                return *(this->operator->());
            }
 
            pointer operator->() const {
                if (isEnd(m_pCurrent))
                    CATAPULT_THROW_OUT_OF_RANGE("cannot dereference at end");
 
                return m_pCurrent;
            }
 
        private:
            constexpr bool isEntityInBuffer(value_type* pEntity) const noexcept {
                return
                        ToBytePointer(pEntity) <= endBytePointer() &&
                        ToBytePointer(pEntity) + sizeof(pEntity->Size) <= endBytePointer() && // ensure Size is readable
                        ToBytePointer(pEntity) + pEntity->Size <= endBytePointer();
            }
 
            constexpr bool isEnd(value_type* pEntity) const noexcept {
                return endBytePointer() == ToBytePointer(pEntity);
            }
 
            constexpr auto endBytePointer() const noexcept {
                return ToBytePointer(m_pStart) + m_state.Size;
            }
 
            void checkError() {
                if (isEnd(m_pCurrent) || (isEntityInBuffer(m_pCurrent) && m_pCurrent->Size >= sizeof(TEntity)))
                    return;
 
                m_pCurrent = reinterpret_cast<value_type*>(endBytePointer());
                m_state.HasError = true;
                if (m_state.ThrowOnError)
                    CATAPULT_THROW_RUNTIME_ERROR("error encountered while iterating");
            }
 
        private:
            value_type* m_pStart;
            value_type* m_pCurrent;
            State& m_state;
        };
 
    public:
        auto cbegin() const {
            return iterator<const TEntity>(m_pStart, m_pStart, m_state);
        }
 
        auto cend() const {
            return iterator<const TEntity>(m_pStart, nullptr, m_state);
        }
 
        auto begin() const {
            return iterator<TEntity>(m_pStart, m_pStart, m_state);
        }
 
        auto end() const {
            return iterator<TEntity>(m_pStart, nullptr, m_state);
        }
 
    public:
        bool hasError() const {
            return m_state.HasError;
        }
 
    private:
        TEntity* m_pStart;
        mutable State m_state;
    };
 
    template<typename TEntity>
    constexpr BasicContiguousEntityContainer<TEntity> MakeContiguousEntityContainer(
            TEntity* pEntity,
            size_t size,
            EntityContainerErrorPolicy errorPolicy = EntityContainerErrorPolicy::Throw) {
        return BasicContiguousEntityContainer<TEntity>(pEntity, size, errorPolicy);
    }
}}