RdbTypedColumnContainer.h

Go to the documentation of this file.

 
#pragma once
#include "KeySerializers.h"
#include "RdbColumnContainer.h"
#include "RocksDatabase.h"
#include "catapult/exceptions.h"
#include "catapult/types.h"
 
namespace catapult { namespace cache {
 
    template<typename TDescriptor, typename TContainer = RdbColumnContainer>
    class RdbTypedColumnContainer : public TContainer {
    public:
        using KeyType = typename TDescriptor::KeyType;
        using ValueType = typename TDescriptor::ValueType;
        using StorageType = typename TDescriptor::StorageType;
 
    public:
        class const_iterator {
        private:
            using KeyType = typename TDescriptor::KeyType;
            using ValueType = typename TDescriptor::ValueType;
            using StorageType = typename TDescriptor::StorageType;
 
        public:
            bool operator==(const const_iterator& rhs) const {
                return m_iterator == rhs.m_iterator;
            }
 
            bool operator!=(const const_iterator& rhs) const {
                return !(*this == rhs);
            }
 
        public:
            const StorageType& operator*() const {
                if (RdbDataIterator::End() == m_iterator)
                    CATAPULT_THROW_INVALID_ARGUMENT("dereference on empty iterator");
 
                if (!m_pStorage) {
                    auto value = TDescriptor::Serializer::DeserializeValue(m_iterator.buffer());
                    m_pStorage = std::make_unique<StorageType>(TDescriptor::ToStorage(value));
                }
 
                return *m_pStorage;
            }
 
            const StorageType* operator->() const {
                return &operator*();
            }
 
        public:
            const RdbDataIterator& dbIterator() const {
                return m_iterator;
            }
 
            RdbDataIterator& dbIterator() {
                return m_iterator;
            }
 
        private:
            RdbDataIterator m_iterator;
            mutable std::shared_ptr<StorageType> m_pStorage;
        };
 
    public:
        template<typename TDatabase = RocksDatabase>
        RdbTypedColumnContainer(TDatabase& database, size_t columnId) : TContainer(database, columnId)
        {}
 
    public:
        bool empty() const {
            return 0 == TContainer::size();
        }
 
    public:
 
#if !defined(NDEBUG) && defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4702) /* "unreachable code" */
#endif
 
        void insert(const StorageType& element) {
            TContainer::insert(
                    SerializeKey(TDescriptor::ToKey(element)),
                    TDescriptor::Serializer::SerializeValue(TDescriptor::ToValue(element)));
        }
 
#if !defined(NDEBUG) && defined(_MSC_VER)
#pragma warning(pop)
#endif
 
        const_iterator find(const KeyType& key) const {
            const_iterator iter;
            TContainer::find(SerializeKey(key), iter.dbIterator());
            return iter;
        }
 
        size_t prune(const KeyType& key) {
            return TContainer::prune(TDescriptor::Serializer::KeyToBoundary(key));
        }
 
        void remove(const KeyType& key) {
            TContainer::remove(SerializeKey(key));
        }
 
        const_iterator cend() const {
            return const_iterator();
        }
    };
}}