Value.h

 
#ifndef ACTIVE_SETTING_VALUE
#define ACTIVE_SETTING_VALUE
 
#include "Active/Utility/Cloner.h"
#include "Active/Utility/Guid.h"
#include "Active/Utility/String.h"
#include "Active/Utility/Time.h"
 
namespace active::setting {
    
    class Value : public active::utility::Cloner {
    public:
        
        // MARK: - Types
        
        using Unique = std::unique_ptr<Value>;
        using Shared = std::shared_ptr<Value>;
        using Option = std::optional<Value>;
        
        enum class Status {
            undefined = 0,
            bad,
            good,
        };
        
        enum class Type {
            null = 0,
            boolType,
            idType,
            intType,
            floatType,
            stringType,
            timeType,
        };
        
        using enum Status;
        using enum Type;
 
        // MARK: - Static functions
        
        static std::optional<Type> typeFromName(const utility::String& text);
        static utility::String nameForType(Type type);
        
        // MARK: - Constructors
        
        Value(Status stat = good) { status = stat; }
        virtual ~Value() = default;
        
        virtual Value* clonePtr() const override = 0;
        
        // MARK: - Public variables
        
        Status status;
 
        // MARK: - Operators
        
        virtual bool operator==(const Value& ref) const = 0;
        bool operator!=(const Value& ref) const { return !((*this) == ref); }
        virtual bool operator<(const Value& ref) const = 0;
        virtual Value& operator=(const Value& val) = 0;
        virtual Value& operator=(bool val) = 0;
        virtual Value& operator=(int32_t val) = 0;
        virtual Value& operator=(uint32_t val) = 0;
        virtual Value& operator=(int64_t val) = 0;
        virtual Value& operator=(double val) = 0;
        virtual Value& operator=(const active::utility::String& val) = 0;
        virtual Value& operator=(const char* val) { return operator=(utility::String{val}); }
        virtual Value& operator=(const active::utility::Guid& val) = 0;
        virtual Value& operator=(const active::utility::Time& val) = 0;
        
        // MARK: - Conversion operators
 
        virtual operator bool() const = 0;
        virtual operator int32_t() const = 0;
        virtual operator uint32_t() const = 0;
        virtual operator int64_t() const = 0;
        virtual operator double() const = 0;
        virtual operator active::utility::String() const = 0;
        virtual operator active::utility::Guid() const = 0;
        virtual operator active::utility::Time() const = 0;
        
        // MARK: - Functions (const)
        
        virtual bool isGood() const { return (status == good); }
        virtual bool isNull() const = 0;
        virtual Type getType() const = 0;
        
        // MARK: - Functions (mutating)
        
        virtual void setDefault() = 0;
    };
 
    // MARK: - Value smart pointer comparisons
    
    inline bool operator==(const Value::Unique& lhs, const Value::Unique& rhs) {
        return (!lhs || !rhs) ? !(!lhs ^ !rhs) : lhs->operator==(*rhs);
    }
    
    inline bool operator!=(const Value::Unique& lhs, const Value::Unique& rhs) {
        return !(lhs == rhs);
    }
    
    inline bool operator<(const Value::Unique& lhs, const Value::Unique& rhs) {
        return (!lhs || !rhs) ? (!lhs && rhs) : lhs->operator<(*rhs);
    }
    
    inline bool operator==(const Value::Shared& lhs, const Value::Shared& rhs) {
        return (!lhs || !rhs) ? !(!lhs ^ !rhs) : lhs->operator==(*rhs);
    }
    
    inline bool operator!=(const Value::Shared& lhs, const Value::Shared& rhs) {
        return !(lhs == rhs);
    }
    
    inline bool operator<(const Value::Shared& lhs, const Value::Shared& rhs) {
        return (!lhs || !rhs) ? (!lhs && rhs) : lhs->operator<(*rhs);
    }
    
}
 
#endif  //ACTIVE_SETTING_VALUE