MapMetadata.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <AtomsCore/Globals.h>
#include <AtomsCore/Metadata/Metadata.h>
#include <string>
#include <map>
#include <vector>
 
namespace AtomsCore
{
 
 
    class ATOMSCORE_EXPORT MapMetadata: public Metadata
    {
    public:
 
        typedef std::string Key;
 
        typedef std::map<Key, AtomsPtr<Metadata> > valueType; 
 
 
        std::string typeStr() const;
 
        static std::string staticTypeStr();
 
 
        unsigned int typeId() const;
 
        static unsigned int staticTypeId();
 
        MapMetadata();
 
        MapMetadata(const MapMetadata& rhs);
 
        ~MapMetadata();
 
        MapMetadata& operator=(const MapMetadata& other);
 
 
        virtual void copy(Metadata *other);
 
 
        virtual AtomsPtr<Metadata> clone() const;
 
 
        virtual size_t memSize() const;
 
 
        unsigned int size() const;
 
 
        bool hasKey(const Key& key) const;
        
 
        std::vector<Key> getKeys() const;
 
 
        AtomsPtr<Metadata> getEntry(const Key& key);
 
 
        AtomsPtr<const Metadata> getEntry(const Key& key) const;
 
 
        template<class T>
        AtomsPtr<T> getTypedEntry(const Key& key);
 
 
        template<class T>
        AtomsPtr<const T> getTypedEntry(const Key& key) const;
 
 
        template<class T>
        T* getTypedEntryRaw(const Key& key);
 
        /*
        \param key Entry key
        */
        void eraseEntry(const Key& key);
 
 
        void addEntry(const Key& key, AtomsPtr<Metadata>& data, bool cloneData = true);
 
 
        void addEntry(const Key& key, const AtomsPtr<const Metadata>& data);
 
 
        void addEntry(const Key& key, Metadata* data);
 
 
        void insertEntry(const Key& key, AtomsPtr<Metadata> data);
 
        void addEmptyEntry(const Key& key);
 
 
        void clear();
 
        inline valueType::iterator begin();
 
        inline valueType::iterator end();
 
        inline valueType::const_iterator cbegin() const;
 
        inline valueType::const_iterator cend() const;
 
        virtual void hash(MurmurHash3& hasher) const;
 
        inline valueType& data();
 
        inline const valueType& data() const;
 
        virtual void* dataPtr() { return reinterpret_cast<void*>(&m_value); }
 
    public:
 
 
        static Metadata* creator();
 
        bool serialise(Archive& outStream) const;
 
        bool deserialise(Archive& inStream);
 
        void toString(std::stringstream& ss) const;
 
        bool serialiseCompressed(Archive& outStream) const;
 
        bool deserialiseCompressed(Archive& outStream);
 
        bool deserialiseKeys(Archive& outStream, const std::vector<std::string>& keys, bool append = false);
 
        bool deserialiseKeys(const std::string& filePath, const std::vector<std::string>& keys, bool append = false, bool multithread = false);
 
    private:
 
        valueType m_value;
    };
}
namespace AtomsCore
{
    ATOMSCORE_EXPORT AtomsCore::Archive& operator<<(AtomsCore::Archive& os, const AtomsCore::MapMetadata& data);
 
    ATOMSCORE_EXPORT AtomsCore::Archive& operator >> (AtomsCore::Archive& is, AtomsCore::MapMetadata& data);
}
#include "MapMetadata.impl.h"