CompactMosaicMap.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/utils/Hashers.h"
#include "catapult/utils/NonCopyable.h"
#include "catapult/exceptions.h"
#include "catapult/types.h"
#include <map>
 
namespace catapult { namespace state {
 
    //        This is acceptable for mosaics stored in AccountBalances but not for a general purpose map.
    class CompactMosaicMap : utils::MoveOnly {
    private:
        static constexpr auto Array_Size = 5;
 
        // in order for this map to behave like std::unordered_map, the element type needs to be a pair, not model::Mosaic
        using Mosaic = std::pair<const MosaicId, Amount>;
        using MutableMosaic = std::pair<MosaicId, Amount>;
 
        // gcc strict aliasing workaround because pair<X, Y> and pair<const X, Y> are two different types
        struct MosaicUnion {
        public:
            MosaicUnion() : Mosaic()
            {}
 
            MosaicUnion(MosaicUnion&& rhs) : Mosaic(std::move(rhs.Mosaic))
            {}
 
        public:
            MosaicUnion& operator=(MosaicUnion&& rhs) {
                Mosaic = std::move(rhs.Mosaic);
                return *this;
            }
 
        public:
            union {
                MutableMosaic Mosaic;
                CompactMosaicMap::Mosaic ConstMosaic;
            };
        };
 
        using MosaicArray = std::array<MosaicUnion, Array_Size>;
        using MosaicMap = std::map<MosaicId, Amount>;
 
    private:
        struct SecondLevelStorage {
            MosaicArray ArrayStorage;
            uint8_t ArraySize;
            std::unique_ptr<MosaicMap> pMapStorage;
        };
 
        struct FirstLevelStorage {
        public:
            MosaicUnion Value;
            std::unique_ptr<SecondLevelStorage> pNextStorage;
 
        public:
            bool hasValue() const;
 
            bool hasArray() const;
 
            bool hasMap() const;
 
        public:
            uint8_t& arraySize() const;
 
            MosaicArray& array() const;
 
            MosaicMap& map() const;
        };
 
    private:
        enum class MosaicSource { Value, Array, Map };
 
        struct MosaicLocation {
        public:
            MosaicLocation()
                    : Source(static_cast<MosaicSource>(-1))
                    , ArrayIndex(0)
                    , MapIterator()
            {}
 
        public:
            MosaicSource Source;
            size_t ArrayIndex;
            MosaicMap::iterator MapIterator;
        };
 
    private:
        class basic_iterator {
        public:
            using difference_type = std::ptrdiff_t;
            using iterator_category = std::forward_iterator_tag;
 
        public:
            enum class Stage { Start, Value, Array, Map, End };
 
        public:
            explicit basic_iterator(FirstLevelStorage& storage, Stage stage);
 
            explicit basic_iterator(FirstLevelStorage& storage, const MosaicLocation& location);
 
        public:
            bool operator==(const basic_iterator& rhs) const;
 
            bool operator!=(const basic_iterator& rhs) const;
 
        public:
            basic_iterator& operator++();
 
            basic_iterator operator++(int);
 
        protected:
            Mosaic& current() const;
 
        private:
            void advance();
 
            void setValueMosaic();
 
            void setArrayMosaic();
 
            void setMapMosaic();
 
            void setEnd();
 
            bool isEnd() const;
 
        private:
            FirstLevelStorage& m_storage;
            Stage m_stage;
            Mosaic* m_pCurrent;
 
            // indexing into sub containers
            size_t m_arrayIndex;
            MosaicMap::iterator m_mapIterator;
        };
 
        template<typename T>
        class basic_iterator_t : public basic_iterator {
        public:
            using value_type = T;
            using pointer = value_type*;
            using reference = value_type&;
 
        public:
            using basic_iterator::basic_iterator;
 
        public:
            reference operator*() const {
                return current();
            }
 
            pointer operator->() const {
                return &current();
            }
        };
 
    public:
        using const_iterator = basic_iterator_t<const Mosaic>;
 
        using iterator = basic_iterator_t<Mosaic>;
 
    public:
        const_iterator begin() const;
 
        const_iterator end() const;
 
        iterator begin();
 
        iterator end();
 
    public:
        bool empty() const;
 
        size_t size() const;
 
        const_iterator find(MosaicId id) const;
 
        iterator find(MosaicId id);
 
        void insert(const Mosaic& pair);
 
        void erase(MosaicId id);
 
        void optimize(MosaicId id);
 
    private:
        bool find(MosaicId id, MosaicLocation& location) const;
 
        void insertIntoArray(size_t index, const Mosaic& pair);
 
        void insertIntoMap(const Mosaic& pair);
 
        void eraseFromArray(size_t index);
 
        void compact();
 
    private:
        FirstLevelStorage m_storage;
        MosaicId m_optimizedMosaicId;
    };
}}