MeasuredValue.h

 
#ifndef ACTIVE_SETTING_MEASURED_VALUE
#define ACTIVE_SETTING_MEASURED_VALUE
 
#include "Active/Setting/Values/DoubleValue.h"
#include "Active/Utility/BufferIn.h"
 
#include <functional>
 
namespace active::setting {
 
 
    template<class T>
    class MeasuredValue : public DoubleValue {
    public:
        
        // MARK: - Types
        
            //Measurement unit type
        using Type = typename T::Type;
        using UnitRetrieval = std::function<T()>;
        
        // MARK: - Constructors
 
        MeasuredValue() {}
        explicit MeasuredValue(double val) : DoubleValue(val) {}
        explicit MeasuredValue(const T& unit, double val = 0.0) : DoubleValue(val), m_unit{unit} {}
        MeasuredValue(UnitRetrieval unitFinder, double val = 0.0) : DoubleValue(val), m_unitFinder{unitFinder} {}
        
        // MARK: - Operators
        
        using DoubleValue::operator=;
        
        Value& operator=(const utility::String& val) override {
            return assign(val, getUnit());
        }
 
        operator utility::String() const override {
            return (*this)(getUnit());
        }
        virtual utility::String operator()(const T& unit) const {
                //Pair a value with a unit type
            using UnitValue = std::pair<double, Type>;
                //Collect the string from a value (as an integer) before replacing it with the remaining fraction of a specified type
            auto collect = [](UnitValue& value, const T& unit, Type type) {
                UnitValue otherValue{0.0, type};
                auto total = value.first;
                value.first = math::roundDown(total, 1.0);
                otherValue.first = unit.conversion(otherValue.second, unit.conversion(value.second, total - value.first, true));
                utility::String result;
                if (unit.isLeadingZero || !math::isZero(value.first, 1.0))
                    result = utility::String{value.first, 1.0} + unit.suffix(value.second);
                value = otherValue;
                return result;
            };
 
            bool isSuffix = unit.isUnitSuffix || unit.secondary;
            UnitValue value{unit.conversion(unit.primary, data), unit.primary};
            utility::String result;
                //Split primary and second value when a second unit is specified
            if (unit.secondary) {
                result = collect(value, unit, *unit.secondary);
                    //Split secondary and tertiary value when a third unit is specified
                if (unit.tertiary)
                    result += " " + collect(value, unit, *unit.tertiary);
            }
                //Floating point output
            if (unit.isDecimal()) {
                if (!result.empty())
                    result += " ";
                result += utility::String{value.first, unit.eps()};
            } else {
                    //Fractional output
                auto wholePart = math::roundDown(value.first, 1.0);
                if (!math::isZero(wholePart)) {
                    value.first -= wholePart;
                    if (!result.empty())
                        result += " ";
                    result += utility::String{wholePart, 1.0};
                }
                auto dividend = static_cast<uint64_t>(math::round(fabs(value.first) / unit.eps(), 1.0));
                if (dividend != 0) {
                    auto divisor = static_cast<uint64_t>(unit.divisor());
                    while ((dividend % 2) == 0) {
                        dividend /= 2;
                        divisor /= 2;
                    }
                    if (!result.empty())
                        result += " ";
                    result += utility::String{dividend} + "/" + utility::String{divisor};
                }
                if (result.empty())
                    result = "0";
            }
            if (isSuffix)
                result += unit.suffix(value.second);
            return result;
        }
        
        // MARK: - Functions (const)
 
        virtual T getUnit() const { return m_unitFinder ? m_unitFinder() : m_unit; }
        
        // MARK: - Functions (mutating)
        
        virtual void setUnit(const T& unit) { m_unit = unit; }
        virtual void setUnit(UnitRetrieval unitFinder) { m_unitFinder = unitFinder; }
        virtual Value& assign(const utility::String& val, const T& unit) {
                //Mark the value as bad until we establish a valid measurement from the text
            data = 0.0;
            status = bad;
                //Find any explicit units in the words to create a list of measurement expressions
            using UnitExpression = std::pair<utility::String, Type>;
            std::vector<UnitExpression> measureExpressions;
            utility::String::size_type start = 0;
            while (start < val.size()) {
                if (auto match = unit.findSuffix(val, start); match) {
                    if (match->second == 0)
                        return *this;   //A unit is leading the expression - not accepted as valid input
                    measureExpressions.push_back(UnitExpression(val.substr(start, match->second - start), match->first));
                    start = match->second + unit.suffix(match->first).size();
                } else {
                    measureExpressions.push_back(UnitExpression(val.substr(start), unit.primary));  //Use the value unit unit as a default
                    break;
                }
            }
                //Get the localised thousands separator
            const auto& numPunct{std::use_facet<std::numpunct<char>>(std::locale{})};
            utility::String thousandsSep{numPunct.thousands_sep()};
                //Extract measurement values from each expression
            for (auto& expression : measureExpressions) {
                    //Break the expression into whitespace separated words
                auto words = utility::BufferIn{expression.first}.readWords();
                if (words.empty())
                    continue;
                for (auto& word : words) {
                        //Strip out the thousands separator
                    word.replaceAll(thousandsSep, utility::String{});
                        //Values can be expressed as a fraction - allow for dividend/divisor
                    auto dividend = 0.0, divisor = 1.0;
                    DoubleValue number;
                        //Attempt to extract a divisor
                    if (auto divisionPos = word.find("/"); divisionPos) {
                        if (number = word.substr(*divisionPos + 1); (number.status == good) && !math::isZero(number.data))
                            divisor = number;
                        else
                            return *this;   //invalid divisor value
                        word = word.substr(0, divisionPos);
                    }
                    number = word;
                    if (number.status == good)
                        dividend = number;
                    else
                        return *this;   //invalid dividend value
                    status = good;
                    data += unit.conversion(expression.second, dividend / divisor, true);
                }
            }
            return *this;
        }
        
    private:
        T m_unit;
        UnitRetrieval m_unitFinder;
    };
    
}
 
#endif //ACTIVE_SETTING_MEASURED_VALUE