ValueSetting.h

 
#ifndef ACTIVE_SETTING_VALUE_SETTING
#define ACTIVE_SETTING_VALUE_SETTING
 
#include "Active/Container/Vector.h"
#include "Active/Setting/Setting.h"
#include "Active/Setting/Values/Value.h"
#include "Active/Setting/Values/ValueBase.h"
 
#include <set>
 
namespace active::setting {
 
    class ValueSetting : public setting::Setting, public container::Vector<Value> {
    public:
        
        // MARK: - Types
        
            //The base class of this setting
        using base = container::Vector<Value>;
        using Unique = std::unique_ptr<ValueSetting>;
        using Shared = std::shared_ptr<ValueSetting>;
        using Option = std::optional<ValueSetting>;
        
        // MARK: - Constructors
        
        ValueSetting() {}
        explicit ValueSetting(const utility::NameID& nameID) : Setting{nameID} {}
        ValueSetting(const Value& value, size_t rows = 1, size_t cols = 1);
        ValueSetting(Value&& value, const utility::NameID::Option nameID = std::nullopt);
        template<typename T>
        ValueSetting(const std::vector<T>& values, const utility::NameID::Option nameID = std::nullopt) :
                setting::Setting(nameID) {
            for (auto& value: values)
                emplace_back(ValueBase<T>(value));
        }
        template<typename T>
        ValueSetting(const std::set<T>& values, const utility::NameID::Option nameID = std::nullopt) :
                setting::Setting(nameID) {
            for (auto& value: values)
                emplace_back(ValueBase<T>(value));
        }
        explicit ValueSetting(bool val, const utility::NameID::Option nameID = std::nullopt);
        explicit ValueSetting(int32_t val, const utility::NameID::Option nameID = std::nullopt);
        explicit ValueSetting(uint32_t val, const utility::NameID::Option nameID = std::nullopt);
        explicit ValueSetting(int64_t val, const utility::NameID::Option nameID = std::nullopt);
        explicit ValueSetting(double val, const utility::NameID::Option nameID = std::nullopt);
        explicit ValueSetting(const utility::Guid& val, const utility::NameID::Option nameID = std::nullopt);
        explicit ValueSetting(const utility::String& val, const utility::NameID::Option nameID = std::nullopt);
        explicit ValueSetting(const utility::Time& val, const utility::NameID::Option nameID = std::nullopt);
 
        ValueSetting(const ValueSetting& source) = default;
        ValueSetting(ValueSetting&& source) noexcept;
 
        virtual ~ValueSetting() = default;
 
        virtual ValueSetting* clonePtr() const override { return new ValueSetting(*this); }
 
        // MARK: - Operators (const)
        
        const Value& operator()(size_t row = 0, size_t col = 0) const { return *(*this)[getValueIndex(row, col)]; }
        virtual bool operator==(const Setting& ref) const override;
        virtual bool operator<(const Setting& ref) const override;
 
        // MARK: - Operators (mutating)
        
        Value& operator()(size_t row = 0, size_t col = 0) { return *(*this)[getValueIndex(row, col)]; }
        virtual Setting& operator=(const Setting& source) override;
        ValueSetting& operator=(ValueSetting&& source) = default;
 
        // MARK: - Conversion operators
        
        operator bool() const { return getValue<bool>(); }
        operator int32_t() const { return getValue<int32_t>(); }
        operator uint32_t() const { return getValue<uint32_t>(); }
        operator int64_t() const { return getValue<int64_t>(); }
        operator double() const { return getValue<double>(); }
        operator active::utility::String() const { return getValue<utility::String>(); }
        operator active::utility::Guid() const { return getValue<utility::Guid>(); }
        operator active::utility::Time() const { return getValue<utility::Time>(); }
        
        template<typename T>
        operator std::vector<T>() const {
            std::vector<T> result;
            for (const auto& value : *this)
                result.push_back(*value);
            return result;
        }
 
        // MARK: - Functions (const)
        
        std::optional<Value::Type> getDefaultType() const { return m_type; }
        size_t getColumnSize() const { return m_columns; }
        
        bool empty() const override { return base::empty(); }
        bool isGood(size_t row = 0, size_t col = 0) const { return (*this)[getValueIndex(row, col)]->isGood(); }
        Value::Status status(size_t row = 0, size_t col = 0) const { return (*this)[getValueIndex(row, col)]->status; }
        bool boolVal(size_t row = 0, size_t col = 0) const { return getValue<bool>(row, col); }
        int32_t int32Val(size_t row = 0, size_t col = 0) const { return getValue<int32_t>(row, col); }
        uint32_t uint32Val(size_t row = 0, size_t col = 0) const { return getValue<uint32_t>(row, col); }
        int64_t int64Val(size_t row = 0, size_t col = 0) const { return getValue<int64_t>(row, col); }
        double doubleVal(size_t row = 0, size_t col = 0) const { return getValue<double>(row, col); }
        active::utility::String stringVal(size_t row = 0, size_t col = 0) const { return getValue<utility::String>(row, col); }
        active::utility::Guid guidVal(size_t row = 0, size_t col = 0) const { return getValue<utility::Guid>(row, col); }
        active::utility::Time timeVal(size_t row = 0, size_t col = 0) const { return getValue<utility::Time>(row, col); }
 
        // MARK: - Functions (mutating)
        
        void setDefaultType(std::optional<Value::Type> type = std::nullopt) { m_type = type; }
        void setColumnSize(size_t size) { m_columns = std::max(base::size(), std::min(size_t(1), size)); }
        
        void clear() override   { base::clear(); }
        void setDefault() override;
        
    protected:
        size_t getValueIndex(size_t row = 0, size_t col = 0) const {
            auto result = row * m_columns + col;
            if (result >= base::size())
                throw std::out_of_range("");
            return result;
        }
        template<typename T>
        T getValue(size_t row = 0, size_t col = 0) const {
            return *(*this)[getValueIndex(row, col)];
        }
        
    private:
        std::optional<Value::Type> m_type;
        size_t m_columns = 1;
    };
    
}
 
#endif  //ACTIVE_SETTING_VALUE_SETTING