KeyValueManager.h

Go to the documentation of this file.

// Copyright 2014 GSI, Inc. All rights reserved.
//
//
//
#ifndef __DDS__KeyValueManager__
#define __DDS__KeyValueManager__

// DDS
#include "DeleteKeyCmd.h"
#include "Topology.h"
#include "UpdateKeyCmd.h"
// STD
#include <map>
#include <mutex>

namespace dds
{
    namespace commander_cmd
    {
        enum class EKeyUpdateResult
        {
            Correct,
            VersionMismatchError,
            KeyNotFoundError
        };


        struct SKeyValueRecord
        {
            typedef std::shared_ptr<SKeyValueRecord> ptr_t;
            typedef std::weak_ptr<SKeyValueRecord> wptr_t;
            // task ID --> STaskKeyValue
            typedef std::multimap<uint64_t, SKeyValueRecord::ptr_t> taskMap_t;
            // key --> STaskKeyValue
            // typedef std::map<std::string, SKeyValueRecord::ptr_t> keyMap_t;

            SKeyValueRecord();
            ~SKeyValueRecord();

            EKeyUpdateResult updateKeyValue(const protocol_api::SUpdateKeyCmd& _cmd,
                                            protocol_api::SUpdateKeyCmd& _serverCmd);
            void deleteKeyValue();
            std::string getKeyValueString() const;

            friend std::ostream& operator<<(std::ostream& _stream, const SKeyValueRecord& _value);

          private:
            mutable std::mutex m_mutex;
            protocol_api::SUpdateKeyCmd m_keyValue;
            bool m_deleted;
        };

        inline std::ostream& operator<<(std::ostream& _stream, const SKeyValueRecord& _value)
        {
            std::lock_guard<std::mutex> lock(_value.m_mutex);

            return _stream << "SKeyValueRecord cmd: " << _value.m_keyValue << " deleted: " << _value.m_deleted;
        }

        struct SPropertyRecord
        {
            typedef std::shared_ptr<SPropertyRecord> ptr_t;
            typedef std::weak_ptr<SPropertyRecord> wptr_t;
            // property --> SPropertyRecord
            typedef std::map<std::string, SPropertyRecord::ptr_t> propertyMap_t;

            SPropertyRecord();
            ~SPropertyRecord();

            void addKeyValueRecord(uint64_t _taskID, SKeyValueRecord::ptr_t _keyValueRecord);

            EKeyUpdateResult updateKeyValue(const protocol_api::SUpdateKeyCmd& _cmd,
                                            protocol_api::SUpdateKeyCmd& _serverCmd);

            std::string getKeyValueString() const;

            friend std::ostream& operator<<(std::ostream& _stream, const SPropertyRecord& _value);

          private:
            SKeyValueRecord::taskMap_t m_taskMap;
        };

        inline std::ostream& operator<<(std::ostream& _stream, const SPropertyRecord& _value)
        {
            _stream << "SPropertyRecord\n";
            for (const auto& v : _value.m_taskMap)
            {
                _stream << "   " << v.first << " --> " << *(v.second) << "\n";
            }
            return _stream;
        }

        class CKeyValueManager
        {
          public:
            CKeyValueManager();
            ~CKeyValueManager();

            void initWithTopology(const topology_api::CTopology& _topology);
            void updateWithTopology(const topology_api::CTopology& _topology,
                                    const topology_api::CTopology::HashSet_t& _removedTasks,
                                    const topology_api::CTopology::HashSet_t& _addedTasks);
            EKeyUpdateResult updateKeyValue(const protocol_api::SUpdateKeyCmd& _cmd,
                                            protocol_api::SUpdateKeyCmd& _serverCmd);
            void deleteKeyValue(uint64_t _taskID);

            std::string getKeyValueString(const std::string _propertyID) const;
            std::string getPropertyString() const;

            friend std::ostream& operator<<(std::ostream& _stream, const CKeyValueManager& _value);

          private:
            void initWithTopologyImpl(const topology_api::CTopology& _topology,
                                      const topology_api::CTopology::HashSet_t* _addedTasks);

            SPropertyRecord::propertyMap_t m_propertyMap;
            // The map is used to query specific records by task ID, for example, to fetch or delete all records for a
            // specific task ID.
            SKeyValueRecord::taskMap_t m_taskMap;
        };

        inline std::ostream& operator<<(std::ostream& _stream, const CKeyValueManager& _value)
        {
            _stream << "CKeyValueManager\n";
            _stream << "[Property map]\n";
            for (const auto& v : _value.m_propertyMap)
            {
                _stream << "   " << v.first << " --> " << *(v.second) << "\n";
            }
            _stream << "[Task map]\n";
            for (const auto& v : _value.m_taskMap)
            {
                _stream << "   " << v.first << " --> " << *(v.second) << "\n";
            }

            return _stream;
        }
    }
}

#endif /* defined(__DDS__KeyValueManager__) */