MetadataImpl.impl.h

namespace AtomsCore
{
    template <class T>
    MetadataImpl<T>::MetadataImpl() :
        Metadata(),
        m_value(T())
    {
        MetadataTraits<T>::initialize(m_value);
    }
 
    template <class T>
    MetadataImpl<T>::MetadataImpl(const T& value) :
        Metadata(),
        m_value(value)
    {
    }
 
    template <class T>
    MetadataImpl<T>::~MetadataImpl()
    {
    }
 
    template <class T>
    MetadataImpl<T>::MetadataImpl(const MetadataImpl& other) :
        Metadata(),
        m_value(other.m_value)
    {
    }
 
    template <class T>
    MetadataImpl<T>& MetadataImpl<T>::operator=(const MetadataImpl& other)
    {
        this->m_value = other.m_value;
        return *this;
    }
 
    template <class T>
    void MetadataImpl<T>::copy(Metadata *other)
    {
        MetadataImpl<T>* data = static_cast<MetadataImpl<T>*>(other);
        if (data)
            this->m_value = data->m_value;
    }
 
    template <class T>
    AtomsPtr<Metadata> MetadataImpl<T>::clone() const
    {
        return AtomsPtr<Metadata>(dynamic_cast<Metadata*>(new MetadataImpl<T>(*this)));
    }
 
    template <class T>
    size_t MetadataImpl<T>::memSize() const
    {
        return sizeof(unsigned int) + AtomsCore::memSize(m_value);
    }
 
    template <class T>
    std::string MetadataImpl<T>::typeStr() const
    {
        return MetadataImpl<T>::staticTypeStr();
    }
 
    template <class T>
    unsigned int MetadataImpl<T>::typeId() const
    {
        return MetadataImpl<T>::staticTypeId();
    }
 
    template <class T>
    void MetadataImpl<T>::set(const T& value)
    {
        m_value = value;
    }
 
    template <class T>
    T MetadataImpl<T>::value() const
    {
        return m_value;
    }
 
    template <class T>
    const T& MetadataImpl<T>::get() const
    {
        return m_value;
    }
 
    template <class T>
    T& MetadataImpl<T>::get()
    {
        return m_value;
    }
 
    template <class T>
    Metadata* MetadataImpl<T>::creator()
    {
        return new MetadataImpl<T>();
    }
 
    template <class T>
    bool MetadataImpl<T>::serialise(Archive& outStream) const
    {
        if (outStream.size == 0)
        {
            outStream.resize(memSize());
        }
 
        outStream << typeId();
        outStream << m_value;
        return true;
    }
 
    template <class T>
    bool MetadataImpl<T>::deserialise(Archive& inStream)
    {
        unsigned int typeIdValue;
        inStream >> typeIdValue;
        inStream >> m_value;
        return true;
    }
 
    template <class T>
    void MetadataImpl<T>::toString(std::stringstream& ss) const
    {
#ifdef ATOMS_UNREAL
 
#else
        ss << m_value;
#endif
    }
 
    template <class T>
    bool MetadataImpl<T>::setWithValuesAndWeights(const std::vector<AtomsPtr<Metadata>> &values, const std::vector<double> &weights)
    {
        return false;
    }
 
    template <class T>
    bool MetadataImpl<T>::setWithValuesAndWeights(const std::vector<Metadata *> &values, const std::vector<double> &weights)
    {
        return false;
    }
 
    template <class T>
    void MetadataImpl<T>::hash(MurmurHash3& hasher) const
    {
        hasher.append(m_value);
    }
 
    template <class T>
    bool MetadataImpl<T>::isEqual(Metadata* right, double err) const
    {
        if (this == right) return true;
 
        if (right->typeId() != typeId())
            return false;
 
        return m_value == static_cast<MetadataImpl<T>*>(right)->get();
    }
 
    template <class T>
    bool MetadataImpl<T>::isGreater(Metadata* right) const
    {
        return false;
    }
 
    template <class T>
    bool MetadataImpl<T>::isLess(Metadata* right) const
    {
        return false;
    }
}