ArrayMetadata.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 ArrayMetadata : public Metadata
    {
    public:
 
        typedef std::vector<AtomsPtr<Metadata> > valueType; 
 
 
        std::string typeStr() const;
 
        static std::string staticTypeStr();
 
 
        unsigned int typeId() const;
 
 
        static unsigned int staticTypeId();
 
        ArrayMetadata();
 
        ArrayMetadata(const ArrayMetadata& rhs);
 
        ~ArrayMetadata();
 
        ArrayMetadata& operator=(const ArrayMetadata& other);
 
 
        virtual void copy(Metadata *other);
 
 
        virtual AtomsPtr<Metadata> clone() const;
 
 
        virtual size_t memSize() const;
 
 
        size_t size() const;
 
 
        AtomsPtr<Metadata> operator[](size_t index);
 
 
        AtomsPtr<const Metadata> operator[](size_t index) const;
 
 
        template<class T>
        AtomsPtr<T> getTypedElement(size_t index);
 
 
        template<class T>
        AtomsPtr<const T> getTypedElement(size_t index) const;
 
        /*
        \param key Entry key
        */
        void erase(size_t index);
 
 
        void push_back(const AtomsPtr<Metadata>& data);
 
 
        void push_back(Metadata* data);
 
 
        void insert(size_t index, const AtomsPtr<Metadata>& data);
 
 
        void insert(size_t index, Metadata* data);
 
 
        void clear();
 
        virtual void hash(MurmurHash3& hasher) 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<size_t>& keys, bool append = false);
 
        bool deserialiseKeys(const std::string& fileName, const std::vector<std::size_t>& keysToDeserialise, bool append = false);
 
    private:
 
        valueType m_value;
    };
}
 
namespace AtomsCore
{
    ATOMSCORE_EXPORT AtomsCore::Archive& operator<<(AtomsCore::Archive& os, const AtomsCore::ArrayMetadata& data);
 
    ATOMSCORE_EXPORT AtomsCore::Archive& operator >> (AtomsCore::Archive& is, AtomsCore::ArrayMetadata& data);
}
#include "ArrayMetadata.impl.h"