ValueWrap.h

 
#ifndef ACTIVE_SERIALISE_VALUE_WRAP
#define ACTIVE_SERIALISE_VALUE_WRAP
 
#include "Active/Serialise/Item/Item.h"
#include "Active/Setting/Values/Value.h"
#include "Active/Utility/Guid.h"
 
#include <functional>
 
namespace active::serialise {
    
    template<class T>
    class ValueWrap : public Item, public std::reference_wrapper<T> {
    public:
        
        // MARK: - Types
        
        using base = std::reference_wrapper<T>;
        
        // MARK: - Constructors
        
        ValueWrap(T& val) : Item(), base(val) {}
            //NB: Value is only mutated within import processes, in which case the object must be mutable (i.e. const discard is safe)
        ValueWrap(const T& val) : base(const_cast<T&>(val)) {}
        
        // MARK: - Functions (const)
 
        virtual bool write(utility::String& dest) const override {
            dest = utility::String{base::get()};
            return true;
        }
        
        // MARK: - Functions (mutating)
 
        virtual bool read(const utility::String& source) override   { base::get() = T{source}; return true; }
        virtual bool read(const setting::Value& source) override {
                //If Value supports conversion to this type, assign directly
            if constexpr(requires (setting::Value& v) { v.operator T(); })
                base::get() = source;
            else {
                utility::String text = source;
                return read(text);  //Otherwise use a string as an intermediate value
            }
            return true;
        }
        virtual void setDefault() override  {}
        virtual std::optional<Item::Type> type() const override  { return Item::Type::number; } //Other types should specialise accordingly
    };
    
    // MARK: - Specialisations for string
 
    template<> inline
    std::optional<Item::Type> ValueWrap<utility::String>::type() const { return Item::Type::text; }
    
    // MARK: - Specialisations for guid
 
    template<> inline
    bool ValueWrap<utility::Guid>::write(utility::String& dest) const {
        dest = base::get();
        return true;
    }
 
    template<> inline
    std::optional<Item::Type> ValueWrap<utility::Guid>::type() const { return Item::Type::text; }
    
    // MARK: - Specialisations for bool
 
    template<> inline
    bool ValueWrap<bool>::read(const utility::String& source) {
        utility::String value = source.lowercase();
        if ((value == "true") || (value == "1"))
            base::get() = true;
        else if ((value == "false") || (value == "0"))
            base::get() = false;
        else
            return false;
        return true;
    } //ValueWrap<bool>::read
    
    
    template<> inline
    bool ValueWrap<bool>::write(utility::String& dest) const {
        dest = get() ? "true" : "false";
        return true;
    } //ValueWrap<bool>::write
    
    
    template<> inline
    std::optional<Item::Type> ValueWrap<bool>::type() const { return Item::Type::boolean; }
    
    using BoolWrap = ValueWrap<bool>;
    using DoubleWrap = ValueWrap<double>;
    using FloatWrap = ValueWrap<float>;
    using Int32Wrap = ValueWrap<int32_t>;
    using Int64Wrap = ValueWrap<int64_t>;
    using StringWrap = ValueWrap<utility::String>;
    using UInt32Wrap = ValueWrap<uint32_t>;
 
}
 
#endif  //ACTIVE_SERIALISE_VALUE_WRAP