CEditNum.hpp

Go to the documentation of this file.

#ifndef LIBS_GUI_CEDITNUM_HPP_
#define LIBS_GUI_CEDITNUM_HPP_
 
#include "core/concepts.hpp"
#include "core/constants.hpp"
#include "ui/gui/CEdit.hpp"
#include "utils/stringUtils.hpp"
 
#include <fmt/format.h>
#include <optional>
#include <string>
#include <type_traits>
 
class CEditNum final : public CEdit
{
public:
    enum class ePrvTimeEdit
    {
        Seconds = iv::constants::time::MillisecondsInSeconds,
        Minutes = iv::constants::time::MillisecondsInMinutes,
        Hours = iv::constants::time::MillisecondsInHours,
        Days = iv::constants::time::MillisecondsInDays,
    };
 
    enum class EPrvTypeEdit
    {
        Double,
 
        Int64_t,
        Int32_t,
        Int16_t,
 
        UInt64_t,
        UInt32_t,
        UInt16_t,
        UInt8_t,
    };
 
    struct SEditNum
    {
        EPrvTypeEdit m_type {EPrvTypeEdit::Double};
        std::optional<ePrvTimeEdit> m_timeEdit {};
 
        std::string m_nameField {};
        std::string m_strData {};
 
        double *m_dataDouble {nullptr};
 
        int64_t *m_dataInt64_t {nullptr};
        int32_t *m_dataInt32_t {nullptr};
        int16_t *m_dataInt16_t {nullptr};
 
        uint64_t *m_dataUInt64_t {nullptr};
        uint32_t *m_dataUInt32_t {nullptr};
        uint16_t *m_dataUInt16_t {nullptr};
        uint8_t *m_dataUInt8_t {nullptr};
 
        bool m_hasInterval {false};
        double m_minData {0.};
        double m_maxData {0.};
        uint8_t maxNumDecimals {0};
    };
 
    template<iv::concepts::IntegerType T>
    static CEditNum *createInteger(const std::string &nameField, T &valueRef, const uint16_t numMaxChar)
    {
        if constexpr (std::is_same_v<T, uint64_t>)
        {
            return CEditNum::createEditUInt64_t(nameField, &valueRef, numMaxChar);
        }
        else if constexpr (std::is_same_v<T, uint32_t>)
        {
            return CEditNum::createEditUInt32_t(nameField, &valueRef, numMaxChar);
        }
        else if constexpr (std::is_same_v<T, uint16_t>)
        {
            return CEditNum::createEditUInt16_t(nameField, &valueRef, numMaxChar);
        }
        else if constexpr (std::is_same_v<T, uint8_t>)
        {
            return CEditNum::createEditUChar(nameField, &valueRef, numMaxChar);
        }
        else if constexpr (std::is_same_v<T, int64_t>)
        {
            return CEditNum::createEditInt64_t(nameField, &valueRef, numMaxChar);
        }
        else if constexpr (std::is_same_v<T, int32_t>)
        {
            return CEditNum::createEditInt32_t(nameField, &valueRef, numMaxChar);
        }
        else if constexpr (std::is_same_v<T, int16_t>)
        {
            return CEditNum::createEditInt16_t(nameField, &valueRef, numMaxChar);
        }
 
        return nullptr;
    }
 
    template<iv::concepts::IntegerType T, iv::concepts::IntegerType R1, iv::concepts::IntegerType R2>
        requires std::is_convertible_v<R1, T> && std::is_convertible_v<R2, T>
    static CEditNum *createIntegerWithInterval(const std::string &nameField, T &valueRef, R1 minValue, R2 maxValue,
                                               uint16_t numMaxChar)
    {
        if (static_cast<T>(minValue) > std::numeric_limits<T>::max())
        {
            throw std::out_of_range("minValue exceeds the limits of type T");
        }
        if (static_cast<T>(maxValue) > std::numeric_limits<T>::max())
        {
            throw std::out_of_range("maxValue exceeds the limits of type T");
        }
 
        if constexpr (std::is_same_v<T, uint64_t>)
        {
            return CEditNum::createEditUInt64WithInterval(nameField, &valueRef, static_cast<uint64_t>(minValue),
                                                          static_cast<uint64_t>(maxValue), numMaxChar);
        }
        else if constexpr (std::is_same_v<T, uint32_t>)
        {
            return CEditNum::createEditUInt32WithInterval(nameField, &valueRef, static_cast<uint32_t>(minValue),
                                                          static_cast<uint32_t>(maxValue), numMaxChar);
        }
        else if constexpr (std::is_same_v<T, uint16_t>)
        {
            return CEditNum::createEditUInt16WithInterval(nameField, &valueRef, static_cast<uint16_t>(minValue),
                                                          static_cast<uint16_t>(maxValue), numMaxChar);
        }
        else if constexpr (std::is_same_v<T, uint8_t>)
        {
            return CEditNum::createEditUCharWithInterval(nameField, &valueRef, static_cast<uint8_t>(minValue),
                                                         static_cast<uint8_t>(maxValue), numMaxChar);
        }
        else if constexpr (std::is_same_v<T, int64_t>)
        {
            return CEditNum::createEditInt64WithInterval(nameField, &valueRef, static_cast<int64_t>(minValue),
                                                         static_cast<int64_t>(maxValue), numMaxChar);
        }
        else if constexpr (std::is_same_v<T, int32_t>)
        {
            return CEditNum::createEditInt32WithInterval(nameField, &valueRef, static_cast<int32_t>(minValue),
                                                         static_cast<int32_t>(maxValue), numMaxChar);
        }
        else if constexpr (std::is_same_v<T, int16_t>)
        {
            return CEditNum::createEditInt16WithInterval(nameField, &valueRef, static_cast<int16_t>(minValue),
                                                         static_cast<int16_t>(maxValue), numMaxChar);
        }
 
        return nullptr;
    }
 
    template<iv::concepts::FloatingPointType T>
    static CEditNum *createFloatingPoint(const std::string &nameField, T &valueRef, uint8_t numMaxDecimals,
                                         uint8_t numMaxChar)
    {
        if constexpr (std::is_same_v<T, double>)
        {
            return CEditNum::createDouble(nameField, &valueRef, numMaxDecimals, numMaxChar);
        }
        else if constexpr (std::is_same_v<T, float>)
        {
            // return CEditNum::createEditFloat(nameField, &valueRef, numMaxChar);
        }
 
        return nullptr;
    }
 
    template<iv::concepts::FloatingPointType T>
    static CEditNum *createFloatingPointWithInterval(const std::string &nameField, T &valueRef, T minValue, T maxValue,
                                                     uint8_t numMaxDecimals, uint8_t numMaxChar)
    {
        if constexpr (std::is_same_v<T, double>)
        {
            return CEditNum::createDoubleWithInterval(nameField, &valueRef, minValue, maxValue, numMaxDecimals,
                                                      numMaxChar);
        }
        else if constexpr (std::is_same_v<T, float>)
        {
            // return CEditNum::createEditFloatWithInterval(nameField, &valueRef, minValue, maxValue, numMaxChar);
        }
 
        return nullptr;
    }
 
    static CEditNum *createTime(const std::string &nameField, ePrvTimeEdit timeFormat, iv::types::milliseconds &time,
                                uint16_t numMaxChar);
    static CEditNum *createTimeWithInterval(const std::string &nameField, ePrvTimeEdit timeFormat,
                                            iv::types::milliseconds &time, iv::types::milliseconds minTime,
                                            iv::types::milliseconds maxTime, uint16_t numMaxChar);
 
    ~CEditNum() override;
 
    [[nodiscard]] double getValueDouble() const;
 
    bool getValueInt64_t(int64_t *value) const;
    bool getValueInt32_t(int32_t *value) const;
    bool getValueInt16_t(int16_t *value) const;
 
    bool getValueUInt64_t(uint64_t *value) const;
    bool getValueUInt32_t(uint32_t *value) const;
    bool getValueUInt16_t(uint16_t *value) const;
    bool getValueUChar(uint8_t *value) const;
 
    template<typename T>
    void setValue(T value)
        requires iv::concepts::IntegerType<T> || iv::concepts::FloatingPointType<T>
    {
        const std::string strValue = iv::utils::formatNumber(value, m_sEditNum->maxNumDecimals);
        setText(strValue);
    }
 
    template<typename T>
    void setInterval(T minValue, T maxValue)
        requires std::is_arithmetic_v<T>
    {
        m_sEditNum->m_hasInterval = true;
        m_sEditNum->m_minData = static_cast<double>(minValue);
        m_sEditNum->m_maxData = static_cast<double>(maxValue);
    }
 
    [[nodiscard]] const std::string &getNameField() const;
 
private:
    static CEditNum *createDouble(const std::string &nameField, double *number, uint8_t numMaxDecimals,
                                  uint8_t numMaxChar);
    static CEditNum *createDoubleWithInterval(const std::string &nameField, double *number, double minDouble,
                                              double maxDouble, uint8_t numMaxDecimals, uint8_t numMaxChar);
 
    static CEditNum *createEditInt64_t(const std::string &nameField, int64_t *number, uint16_t numMaxChar);
    static CEditNum *createEditInt32_t(const std::string &nameField, int32_t *number, int32_t numMaxChar);
    static CEditNum *createEditInt16_t(const std::string &nameField, int16_t *number, uint16_t numMaxChar);
 
    static CEditNum *createEditInt64WithInterval(const std::string &nameField, int64_t *number, int64_t minInt64,
                                                 int64_t maxInt64, int16_t numMaxChar);
    static CEditNum *createEditInt32WithInterval(const std::string &nameField, int32_t *number, int32_t minInt32,
                                                 int32_t maxInt32, int16_t numMaxChar);
    static CEditNum *createEditInt16WithInterval(const std::string &nameField, int16_t *number, int16_t minInt16,
                                                 int16_t maxInt16, int16_t numMaxChar);
 
    static CEditNum *createEditUInt64_t(const std::string &nameField, uint64_t *number, uint16_t numMaxChar);
    static CEditNum *createEditUInt32_t(const std::string &nameField, uint32_t *number, uint16_t numMaxChar);
    static CEditNum *createEditUInt16_t(const std::string &nameField, uint16_t *number, uint16_t numMaxChar);
    static CEditNum *createEditUChar(const std::string &nameField, uint8_t *number, unsigned short numMaxChar);
 
    static CEditNum *createEditUInt64WithInterval(const std::string &nameField, uint64_t *number, uint64_t minUInt64,
                                                  uint64_t maxUInt64, uint16_t numMaxChar);
    static CEditNum *createEditUInt32WithInterval(const std::string &nameField, uint32_t *number, uint32_t minUInt32,
                                                  uint32_t maxUInt32, uint16_t numMaxChar);
    static CEditNum *createEditUInt16WithInterval(const std::string &nameField, uint16_t *number, uint16_t minUInt16,
                                                  uint16_t maxUInt16, uint16_t numMaxChar);
    static CEditNum *createEditUCharWithInterval(const std::string &nameField, uint8_t *number, uint8_t minUInt8,
                                                 uint8_t maxUInt8, unsigned short numMaxChar);
 
    bool filterChar(char car, std::string *filterReasonOpt) override;
    bool filterCharAtEnd(char car, std::string *filterReasonOpt) override;
 
    CEditNum(SEditNum **dataPrivate, std::string *strValue, unsigned short numMaxChar);
 
    SEditNum *m_sEditNum;
};
 
#endif /* LIBS_GUI_CEDITNUM_HPP_ */