ValueBase.h

 
#ifndef ACTIVE_SETTING_VALUE_BASE
#define ACTIVE_SETTING_VALUE_BASE
 
#include "Active/Setting/Values/Value.h"
 
#include <type_traits>
 
namespace active::setting {
    
    template<class T>
    class ValueBase : public Value {
    public:
        
        // MARK: - Constructors
 
        ValueBase() : Value(undefined) {}
        ValueBase(const T& val, Status stat = good) : Value(stat) { data = val; }
        ValueBase(const Value& value) { data = value; }
        ValueBase(const utility::String& stringVal) requires (!std::is_same<T, utility::String>::value) : Value(bad) { *this = stringVal; }
        
        ValueBase(const ValueBase& source) = default;
        
        virtual Value* clonePtr() const override { return new ValueBase<T>{*this}; };
        
        // MARK: - Public variables
        
        T data = T();
        
        // MARK: - Operators
        
        virtual bool operator==(const Value& ref) const override { return data == ref.operator T(); }
        bool operator!=(const Value& ref) const { return !((*this) == ref); }
        virtual bool operator<(const Value& ref) const override { return data < ref.operator T(); }
        virtual Value& operator=(const Value& val) override {
            data = val;
            return *this;
        }
        virtual Value& operator=(bool val) override { status = bad; return *this; }
        virtual Value& operator=(int32_t val) override { status = bad; return *this; }
        virtual Value& operator=(uint32_t val) override { status = bad; return *this; }
        virtual Value& operator=(int64_t val) override { status = bad; return *this; }
        virtual Value& operator=(double val) override { status = bad; return *this; }
        virtual Value& operator=(const active::utility::String& val) override { status = bad; return *this; }
        virtual Value& operator=(const char* val) override { return Value::operator=(val); }
        virtual Value& operator=(const active::utility::Guid& val) override { status = bad; return *this; }
        virtual Value& operator=(const active::utility::Time& val) override { status = bad; return *this; }
        
        // MARK: - Conversion operators
 
        virtual operator bool() const override { return false; }
        virtual operator int32_t() const override { return 0; }
        virtual operator uint32_t() const override { return 0; }
        virtual operator int64_t() const override { return 0; }
        virtual operator double() const override { return 0.0; }
        virtual operator active::utility::String() const override { return active::utility::String{}; }
        virtual operator active::utility::Guid() const override { return active::utility::Guid{}; }
        virtual operator active::utility::Time() const override { return active::utility::Time{}; }
        
        // MARK: - Functions (const)
        
        virtual bool isNull() const override { return data == T{}; }
        virtual Type getType() const override { return null; }
        
        // MARK: - Functions (mutating)
        
        virtual void setDefault() override  { data = T{}; }
    };
    
    //template<> inline
    //Item::Type ValueWrap<utility::String>::type() const { return Item::Type::text; }
 
    template<> inline
    Value& ValueBase<utility::Guid>::operator=(const Value& val) {
        data = val.operator utility::Guid();
        return *this;
    }
 
    
}
 
#endif  //ACTIVE_SETTING_VALUE_BASE