MetadataImpl.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 <AtomsCore/Metadata/MetadataTraits.h>
#include <sstream>
 
#ifdef _WIN32
    #define METADATA_SPEC_DECLARE(TYPE) template class ATOMSCORE_EXPORT MetadataImpl<TYPE>;
#else
    #define METADATA_SPEC_DECLARE(TYPE)
#endif
 
#define DECLARE_METADATA(NAME, TYPE) \
typedef MetadataImpl<TYPE> NAME; \
template<> ATOMSCORE_EXPORT std::string MetadataImpl<TYPE>::staticTypeStr(); \
template<> ATOMSCORE_EXPORT unsigned int MetadataImpl<TYPE>::staticTypeId(); \
template<> ATOMSCORE_EXPORT std::string MetadataImpl<TYPE>::staticBaseTypeStr(); \
METADATA_SPEC_DECLARE(TYPE) \
 
#define DECLARE_METADATA_WITH_BLEND(NAME, TYPE) \
typedef MetadataImpl<TYPE> NAME; \
template<> ATOMSCORE_EXPORT std::string MetadataImpl<TYPE>::staticTypeStr(); \
template<> ATOMSCORE_EXPORT unsigned int MetadataImpl<TYPE>::staticTypeId(); \
template<> ATOMSCORE_EXPORT std::string MetadataImpl<TYPE>::staticBaseTypeStr(); \
template<> ATOMSCORE_EXPORT bool MetadataImpl<TYPE>::setWithValuesAndWeights(const std::vector<AtomsPtr<Metadata>> &values, const std::vector<double> &weights); \
template<> ATOMSCORE_EXPORT bool MetadataImpl<TYPE>::setWithValuesAndWeights(const std::vector<Metadata *> &values, const std::vector<double> &weights); \
METADATA_SPEC_DECLARE(TYPE) \
 
#define DEFINE_METADATA_TYPE(NAME, TYPE, ID) \
template<> std::string MetadataImpl<TYPE>::staticTypeStr() { return #NAME; } \
template<> unsigned int MetadataImpl<TYPE>::staticTypeId() { return  ID; } \
template<> std::string MetadataImpl<TYPE>::staticBaseTypeStr() { return  #TYPE; } \
template class MetadataImpl<TYPE>; \
 
#define DEFINE_METADATA_BASE_BLEND(TYPE, CAST_TYPE) \
template<> bool MetadataImpl<TYPE>::setWithValuesAndWeights(const std::vector<AtomsPtr<Metadata>> &values, const std::vector<double> &weights) \
{ \
    size_t vSize = values.size(); \
    size_t wSize = weights.size(); \
    if (vSize == 0 || vSize != wSize) \
        return false; \
    m_value = static_cast<TYPE>(static_cast<CAST_TYPE>(std::static_pointer_cast<MetadataImpl<TYPE>>(values[0])->get()) * weights[0]); \
    for (size_t i = 1; i < vSize; ++i) \
        m_value += static_cast<TYPE>(static_cast<CAST_TYPE>(std::static_pointer_cast<MetadataImpl<TYPE>>(values[i])->get()) * weights[i]); \
    return true; \
} \
\
template<> bool MetadataImpl<TYPE>::setWithValuesAndWeights(const std::vector<Metadata *> &values, const std::vector<double> &weights) \
{ \
    size_t vSize = values.size(); \
    size_t wSize = weights.size(); \
    if (vSize == 0 || vSize != wSize) \
        return false; \
    m_value = static_cast<TYPE>(static_cast<CAST_TYPE>(static_cast<MetadataImpl<TYPE> *>(values[0])->get()) * weights[0]); \
    for (size_t i = 1; i < vSize; ++i) \
        m_value += static_cast<TYPE>(static_cast<CAST_TYPE>(static_cast<MetadataImpl<TYPE> *>(values[i])->get()) * weights[i]); \
    return true; \
}\
 
#define DEFINE_METADATA_TYPE_WITH_BLEND(NAME, TYPE, ID) \
DEFINE_METADATA_TYPE(NAME, TYPE, ID) \
DEFINE_METADATA_BASE_BLEND(TYPE, double) \
 
#define DEFINE_METADATA_TYPE_WITH_VECTOR_TYPE_BLEND(NAME, TYPE, ID) \
DEFINE_METADATA_TYPE(NAME, TYPE, ID) \
DEFINE_METADATA_BASE_BLEND(TYPE, TYPE) \
 
#define DECLARE_MEADATA_COMPARISION(TYPE) \
template<> ATOMSCORE_EXPORT bool MetadataImpl<TYPE>::isEqual(Metadata* right, double err) const; \
template<> ATOMSCORE_EXPORT bool MetadataImpl<TYPE>::isGreater(Metadata* right) const; \
template<> ATOMSCORE_EXPORT bool MetadataImpl<TYPE>::isLess(Metadata* right) const; \
 
#define DEFINE_MEADATA_BASE_COMPARISION(TYPE) \
template<> bool MetadataImpl<TYPE>::isEqual(Metadata* right, double err) const \
{ \
    if (this == right) return true; \
    if (!right || right->typeId() != typeId()) return false; \
    return m_value == static_cast<MetadataImpl<TYPE>*>(right)->get();\
}\
\
template<> bool MetadataImpl<TYPE>::isGreater(Metadata* right) const \
{\
    if (this == right) return false; \
    if (!right || right->typeId() != typeId()) return false; \
    return m_value > static_cast<MetadataImpl<TYPE>*>(right)->get();\
}\
\
template<> bool MetadataImpl<TYPE>::isLess(Metadata* right) const\
{\
    if (this == right) return false; \
    if (!right || right->typeId() != typeId()) return false; \
    return m_value < static_cast<MetadataImpl<TYPE>*>(right)->get();\
}\
 
#define DEFINE_MEADATA_BASE_ABS_COMPARISION(TYPE) \
template<> bool MetadataImpl<TYPE>::isEqual(Metadata* right, double err) const \
{ \
    if (this == right) return true; \
    if (!right || right->typeId() != typeId()) return false; \
    return std::abs(m_value - static_cast<MetadataImpl<TYPE>*>(right)->get()) < err;\
}\
\
template<> bool MetadataImpl<TYPE>::isGreater(Metadata* right) const \
{\
    if (this == right) return false; \
    if (!right || right->typeId() != typeId()) return false; \
    return m_value > static_cast<MetadataImpl<TYPE>*>(right)->get();\
}\
\
template<> bool MetadataImpl<TYPE>::isLess(Metadata* right) const\
{\
    if (this == right) return false; \
    if (!right || right->typeId() != typeId()) return false; \
    return m_value < static_cast<MetadataImpl<TYPE>*>(right)->get();\
}\
 
#define DEFINE_MEADATA_VECTOR_COMPARISION(TYPE) \
template<> bool MetadataImpl<TYPE>::isEqual(Metadata* right, double err) const \
{ \
    if (this == right) return true; \
    if (right->typeId() != typeId()) return false; \
    return m_value.equalWithAbsError(static_cast<MetadataImpl<TYPE>*>(right)->get(), err);\
}\
\
template<> bool MetadataImpl<TYPE>::isGreater(Metadata* right) const \
{\
    if (this == right) return false; \
    if (right->typeId() != typeId()) return false; \
    auto& rightValue = static_cast<MetadataImpl<TYPE>*>(right)->get(); \
    for (unsigned int i = 0; i < m_value.dimensions(); ++i) \
        if (m_value[i] < rightValue[i]) return false; \
    return true;\
}\
\
template<> bool MetadataImpl<TYPE>::isLess(Metadata* right) const\
{\
    if (this == right) return false; \
    if (right->typeId() != typeId()) return false; \
    auto& rightValue = static_cast<MetadataImpl<TYPE>*>(right)->get(); \
    for (unsigned int i = 0; i < m_value.dimensions(); ++i) \
        if (m_value[i] > rightValue[i]) return false; \
    return true;\
}\
 
namespace AtomsCore
{
    template <typename T>
    class MetadataImpl : public Metadata
    {
    public:
 
        typedef T valueType;
 
        /*
        \return class type string
        */
        std::string typeStr() const;
 
        /*
        \return class type id
        */
        unsigned int typeId() const;
 
        static std::string staticTypeStr();
 
        static unsigned int staticTypeId();
 
        static std::string staticBaseTypeStr();
 
        MetadataImpl();
 
        /*
        \param value Initial value
        */
        MetadataImpl(const T& value);
 
        MetadataImpl(const MetadataImpl& other);
 
        ~MetadataImpl();
 
        MetadataImpl& operator=(const MetadataImpl& other);
 
        /*
        Virtual function to copy the value from one metadata to another using base pointer.
        \param other
        */
        virtual void copy(Metadata *other);
 
        /*
        Clone the obj. It returns a shared pointer to the new allocated object
        */
        virtual AtomsPtr<Metadata> clone() const;
 
        /*
        Memory used when serialized
        */
        virtual size_t memSize() const;
 
        T value() const;
 
        /*
        Get a reference to the stored value
        */
        T& get();
 
        /*
        Get a const reference to the stored value
        */
        const T& get() const;
 
        void set(const T& value);
 
 
        /*
        \return true if the operation was successfull, false otherwise
        */
        virtual bool setWithValuesAndWeights(const std::vector<AtomsPtr<Metadata>> &values, const std::vector<double> &weights);
        virtual bool setWithValuesAndWeights(const std::vector<Metadata *> &values, const std::vector<double> &weights);
 
        virtual void hash(MurmurHash3& hasher) const;
 
 
        virtual bool isEqual(Metadata* right, double err = 0.0) const;
 
        virtual bool isGreater(Metadata* right) const;
 
        virtual bool isLess(Metadata* right) const;
 
        virtual void* dataPtr() { return reinterpret_cast<void*>(&m_value); }
 
    public:
 
 
        static Metadata* creator();
 
        bool serialise(Archive& outArchive) const;
 
        bool deserialise(Archive& inStream);
 
        virtual void toString(std::stringstream& ss) const;
 
    private:
 
        valueType m_value;
    };
}
 
#include "MetadataImpl.impl.h"