value.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
 
#pragma once
 
#include <algorithm>
#include <limits>
#include <ctgmath>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <clocale>
 
#include "value_functions.h"
 
// NOTE: Put all logic in value functions so we can keep using this class in unit tests
 
namespace libscratchcpp
{

class LIBSCRATCHCPP_EXPORT Value
{
    public:
        Value(double numberValue = 0.0)
        {
            value_init(&m_data);
            value_assign_double(&m_data, numberValue);
        }

        template<typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
        Value(T numberValue)
        {
            value_init(&m_data);
            value_assign_double(&m_data, numberValue);
        }

        Value(bool boolValue)
        {
            value_init(&m_data);
            value_assign_bool(&m_data, boolValue);
        }

        Value(const std::string &stringValue)
        {
            value_init(&m_data);
            value_assign_string(&m_data, stringValue);
        }

        Value(const char *stringValue)
        {
            value_init(&m_data);
            value_assign_cstring(&m_data, stringValue);
        }

        Value(const void *pointerValue)
        {
            value_init(&m_data);
            value_assign_pointer(&m_data, pointerValue);
        }

        Value(const ValueData &v)
        {
            value_init(&m_data);
            value_assign_copy(&m_data, &v);
        }
 
        Value(const Value &v)
        {
            value_init(&m_data);
            value_assign_copy(&m_data, &v.m_data);
        }
 
        ~Value() { value_free(&m_data); }

        const ValueData &data() const { return m_data; };

        ValueData &data() { return m_data; }

        ValueType type() const { return m_data.type; }

        bool isInfinity() const { return value_isInfinity(&m_data); }

        bool isNegativeInfinity() const { return value_isNegativeInfinity(&m_data); }

        bool isNaN() const { return value_isNaN(&m_data); }

        bool isNumber() const { return value_isNumber(&m_data); }

        bool isValidNumber() const { return value_isValidNumber(&m_data); }

        bool isInt() const { return value_isInt(&m_data); }

        bool isBool() const { return value_isBool(&m_data); }

        bool isString() const { return value_isString(&m_data); }

        bool isPointer() const { return value_isPointer(&m_data); }

        int toInt() const { return value_toInt(&m_data); }

        long toLong() const { return value_toLong(&m_data); }

        double toDouble() const { return value_toDouble(&m_data); };

        bool toBool() const { return value_toBool(&m_data); };

        std::string toString() const
        {
            std::string ret;
            value_toString(&m_data, &ret);
            return ret;
        };

        std::u16string toUtf16() const
        {
            std::u16string ret;
            value_toUtf16(&m_data, &ret);
            return ret;
        }

        Rgb toRgba() const { return value_toRgba(&m_data); }

        const void *toPointer() const { return value_toPointer(&m_data); };

        void add(const Value &v) { value_add(&m_data, &v.m_data, &m_data); }

        void subtract(const Value &v) { value_subtract(&m_data, &v.m_data, &m_data); }

        void multiply(const Value &v) { value_multiply(&m_data, &v.m_data, &m_data); }

        void divide(const Value &v) { value_divide(&m_data, &v.m_data, &m_data); }

        void mod(const Value &v) { value_mod(&m_data, &v.m_data, &m_data); }
 
        const Value &operator=(double v)
        {
            value_assign_double(&m_data, v);
            return *this;
        }
 
        template<typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
        const Value &operator=(T v)
        {
            value_assign_double(&m_data, v);
            return *this;
        }
 
        const Value &operator=(bool v)
        {
            value_assign_bool(&m_data, v);
            return *this;
        }
 
        const Value &operator=(const std::string &v)
        {
            value_assign_string(&m_data, v);
            return *this;
        }
 
        const Value &operator=(const char *v)
        {
            value_assign_cstring(&m_data, v);
            return *this;
        }
 
        const Value &operator=(const void *v)
        {
            value_assign_pointer(&m_data, v);
            return *this;
        }
 
        const Value &operator=(const ValueData &v)
        {
            value_assign_copy(&m_data, &v);
            return *this;
        }
 
        const Value &operator=(const Value &v)
        {
            value_assign_copy(&m_data, &v.m_data);
            return *this;
        }
 
    private:
        ValueData m_data;
 
        friend bool operator==(const Value &v1, const Value &v2) { return value_equals(&v1.m_data, &v2.m_data); }
 
        friend bool operator!=(const Value &v1, const Value &v2) { return !value_equals(&v1.m_data, &v2.m_data); }
 
        friend bool operator>(const Value &v1, const Value &v2) { return value_greater(&v1.m_data, &v2.m_data); }
 
        friend bool operator<(const Value &v1, const Value &v2) { return value_lower(&v1.m_data, &v2.m_data); }
 
        friend bool operator>=(const Value &v1, const Value &v2) { return v1 > v2 || v1 == v2; }
 
        friend bool operator<=(const Value &v1, const Value &v2) { return v1 < v2 || v1 == v2; }
 
        friend Value operator+(const Value &v1, const Value &v2)
        {
            Value ret;
            value_add(&v1.m_data, &v2.m_data, &ret.m_data);
            return ret;
        }
 
        friend Value operator-(const Value &v1, const Value &v2)
        {
            Value ret;
            value_subtract(&v1.m_data, &v2.m_data, &ret.m_data);
            return ret;
        }
 
        friend Value operator*(const Value &v1, const Value &v2)
        {
            Value ret;
            value_multiply(&v1.m_data, &v2.m_data, &ret.m_data);
            return ret;
        }
 
        friend Value operator/(const Value &v1, const Value &v2)
        {
            Value ret;
            value_divide(&v1.m_data, &v2.m_data, &ret.m_data);
            return ret;
        }
 
        friend Value operator%(const Value &v1, const Value &v2)
        {
            Value ret;
            value_mod(&v1.m_data, &v2.m_data, &ret.m_data);
            return ret;
        }
};
 
} // namespace libscratchcpp