Value.inl

// INFINITY_API_PUBLIC
 
#pragma once
 
namespace Infinity::Types::Core
{
    template<typename T>
    Value<T>::Value()
        : _val()
    { }
    
    template<typename T>
    Value<T>::Value(T& value)
        : _val(value)
    { }
 
    template<typename T>
    template<typename... Args>
    Value<T>::Value(Args&&... args)
        : _val(std::forward<Args>(args)...)
    { }
 
    template<typename T>
    Value<T>::~Value()
    { }
 
    template<typename T>
    std::unique_ptr<Base> Value<T>::clone() const
    {
        return std::make_unique<Value<T>>(*this);
    }
 
    template<typename T>
    Value<T>::operator T&()
    {
        return _val;
    }
 
    template <typename T>
    Value<T>::operator const T&() const
    {
        return _val;
    }
 
    template<typename T>
    Value<T>& Value<T>::operator=(const Value<T>& rhs)
    {
        _val = rhs._val;
        return *this;
    }
 
    template<typename T>
    Value<T>& Value<T>::operator=(const T& rhs)
    {
        _val = rhs;
        return *this;
    }
 
    template<typename T>
    T& Value<T>::get()
    {
        return _val;
    }
 
    template<typename T>
    const T& Value<T>::get() const
    {
        return _val;
    }
 
    template<typename T>
    void Value<T>::set(const T& value)
    {
        _val = value;
    }
 
    template<typename T>
    size_t Value<T>::size() const
    {
        if constexpr (std::is_same_v<T, std::string>)
        {
            return sizeof(size_t) + _val.size();
        } else {
            return sizeof(T);
        }
    }
 
    template<typename T>
    std::istream& Value<T>::legibleDataRead(std::istream& in)
    {
        if constexpr (std::is_same_v<T, std::string>)
        {
            std::getline(in, _val, '\0');
        } else if constexpr (std::is_same_v<T, bool>) {
            std::string s;
            in >> s;
            std::transform(s.begin(), s.end(), s.begin(), ::tolower);
            
            if (s == "true" || s == "1" || s == "yes" || s == "on")
            {
                _val = true;
            } else if (s == "false" || s == "0" || s == "no" || s == "off") {
                _val = false;
            } else {
                in.setstate(std::ios::failbit);
            }
        } else {
            in >> _val;
        }
        return in;
    }
 
    template<typename T>
    std::ostream& Value<T>::legibleDataWrite(std::ostream& out) const
    {
        out << _val;
        return out;
    }
 
    template<typename T>
    const Infinity::Types::TypeID& Value<T>::typeId() const
    {
        return Infinity::Types::getTypeID<Value<T>>();
    }
 
}