DoubleValue.h

 
#ifndef ACTIVE_SETTING_DOUBLE_VALUE
#define ACTIVE_SETTING_DOUBLE_VALUE
 
#include "Active/Setting/Values/ValueBase.h"
#include "Active/Utility/MathFunctions.h"
 
namespace active::setting {
    
    using DoubleValue = ValueBase<double>;
 
    // MARK: - Operators
    
    template<> inline
    Value& DoubleValue::operator=(bool val) {
        data = val ? 1.0 : 0.0;
        status = good;
        return *this;
    }
    template<> inline
    Value& DoubleValue::operator=(int32_t val) {
        data = static_cast<double>(val);
        status = good;
        return *this;
    }
    template<> inline
    Value& DoubleValue::operator=(uint32_t val) {
        data = static_cast<double>(val);
        status = good;
        return *this;
    }
    template<> inline
    Value& DoubleValue::operator=(int64_t val) {
        data = static_cast<double>(val);
        status = good;
        return *this;
    }
    template<> inline
    Value& DoubleValue::operator=(double val) {
        data = val;
        status = good;
        return *this;
    }
    template<> inline
    Value& DoubleValue::operator=(const utility::String& val) {
        if (auto doubleValue = val.toDouble(); doubleValue) {
            data = *doubleValue;
            status = good;
        } else
            status = bad;
        return *this;
    }
    template<> inline
    Value& DoubleValue::operator=(const char* val) {
        return operator=(utility::String{val});
    }
    template<> inline
    Value& DoubleValue::operator=(const utility::Time& val) {
        data = static_cast<double>(val.secondsSince1970()) + (static_cast<double>(val.microsecond()) / 1e6);
        status = good;
        return *this;
    }
    
    // MARK: - Conversion operators
 
    template<> inline
    DoubleValue::operator bool() const { return !math::isZero(data); }
    template<> inline
    DoubleValue::operator int32_t() const { return static_cast<int32_t>(data); }
    template<> inline
    DoubleValue::operator uint32_t() const { return static_cast<uint32_t>(data); }
    template<> inline
    DoubleValue::operator int64_t() const   { return static_cast<int64_t>(data); }
    template<> inline
    DoubleValue::operator double() const { return data; }
    template<> inline
    DoubleValue::operator utility::String() const   { return utility::String{data}; }
    template<> inline
    DoubleValue::operator utility::Time() const { return utility::Time{data}; }
    
    // MARK: - Functions (const)
    
    template<> inline
    bool DoubleValue::isNull() const { return !math::isZero(data); }
    template<> inline
    Value::Type DoubleValue::getType() const { return floatType; };
 
}
 
#endif  //ACTIVE_SETTING_DOUBLE_VALUE