MemoryID.h

Go to the documentation of this file.

#pragma once
 
#include <functional>  // for std::hash
#include <string>
#include <vector>
 
#include "Time.h"
 
 
namespace armarx::armem
{
 
    class MemoryID
    {
    public:
 
        std::string memoryName = "";
        std::string coreSegmentName = "";
        std::string providerSegmentName = "";
        std::string entityName = "";
        Time timestamp = Time::Invalid();
        int instanceIndex = -1;
 
 
    public:
 
        MemoryID();
        explicit MemoryID(const std::string& string);
 
        MemoryID(const std::string& memoryName,
                 const std::string& coreSegmentName,
                 const std::string& providerSegmentName = "",
                 const std::string& entityName = "",
                 Time timestamp = Time::Invalid(),
                 int instanceIndex = -1);
 
 
        bool isWellDefined() const;
 
 
        // Checks whether a specific level is specified.
 
        bool hasMemoryName() const
        {
            return not memoryName.empty();
        }
        bool hasCoreSegmentName() const
        {
            return not coreSegmentName.empty();
        }
        bool hasProviderSegmentName() const
        {
            return not providerSegmentName.empty();
        }
        bool hasEntityName() const
        {
            return not entityName.empty();
        }
        bool hasTimestamp() const
        {
            return timestamp.isValid();
        }
        void clearTimestamp()
        {
            timestamp = Time::Invalid();
        }
        bool hasInstanceIndex() const
        {
            return instanceIndex >= 0;
        }
        void clearInstanceIndex()
        {
            instanceIndex = -1;
        }
 
 
        // Slice getters: Get upper part of the ID.
 
        MemoryID getMemoryID() const;
        MemoryID getCoreSegmentID() const;
        MemoryID getProviderSegmentID() const;
        MemoryID getEntityID() const;
        MemoryID getEntitySnapshotID() const;
        MemoryID getEntityInstanceID() const;
 
        // Slice getter: remove the last set name
        MemoryID removeLeafItem() const;
 
 
        // Slice setters: Set part of the ID.
 
        void setMemoryID(const MemoryID& id);
        void setCoreSegmentID(const MemoryID& id);
        void setProviderSegmentID(const MemoryID& id);
        void setEntityID(const MemoryID& id);
        void setEntitySnapshotID(const MemoryID& id);
        void setEntityInstanceID(const MemoryID& id);
 
        // Return a modified copy.
 
        MemoryID withMemoryName(const std::string& name) const;
        MemoryID withCoreSegmentName(const std::string& name) const;
        MemoryID withProviderSegmentName(const std::string& name) const;
        MemoryID withEntityName(const std::string& name) const;
        MemoryID withTimestamp(Time time) const;
        MemoryID withInstanceIndex(int index) const;
 
 
        // String conversion
 
        std::string str(bool escapeDelimiters = true) const;
 
        std::string timestampStr() const;
        std::string instanceIndexStr() const;
 
        static MemoryID fromString(const std::string& string);
        static Time timestampFromStr(const std::string& timestamp);
        static int instanceIndexFromStr(const std::string& index);
 
 
        std::vector<std::string> getAllItems(bool escapeDelimiters = false) const;
        std::vector<std::string> getItems(bool escapeDelimiters = false) const;
 
 
        // Other utility.
 
        bool hasGap() const;
        std::string getLeafItem() const;
 
 
        // Operators
 
        bool operator ==(const MemoryID& other) const;
        inline bool operator !=(const MemoryID& other) const
        {
            return not (*this == other);
        }
 
        bool operator< (const MemoryID& rhs) const;
        inline bool operator> (const MemoryID& rhs) const
        {
            return rhs < (*this);
        }
        inline bool operator<=(const MemoryID& rhs) const
        {
            return not operator> (rhs);
        }
        inline bool operator>=(const MemoryID& rhs) const
        {
            return not operator< (rhs);
        }
 
        friend std::ostream& operator<<(std::ostream& os, const MemoryID id);
 
 
    private:
 
        static long long parseInteger(const std::string& string, const std::string& semanticName);
        static std::string escapeDelimiter(const std::string& name);
        static std::string escape(const std::string& name, bool escapeDelimiters);
 
        static const std::string delimiter;
 
 
        // Do not allow specifying the delimiter from outside.
        std::string str(const std::string& delimiter, bool escapeDelimiter) const;
 
    };
 
 
    bool contains(const MemoryID& general, const MemoryID& specific);
 
}  // namespace armarx::armem
 
 
namespace std
{
 
    template <>
    struct hash<armarx::armem::MemoryID>
    {
        std::size_t operator()(const armarx::armem::MemoryID& id) const
        {
            const std::string sid = id.str();
            return std::hash<string>()(sid);
        }
    };
 
}