Unit.h

 
#ifndef ACTIVE_MEASURE_UNIT
#define ACTIVE_MEASURE_UNIT
 
#include "Active/Utility/MathFunctions.h"
#include "Active/Utility/String.h"
 
#include <array>
#include <functional>
#include <optional>
 
namespace active::measure {
 
    template<typename T, typename Type>
    struct Unit {
        
        // MARK: - Constructors
        
        Unit(Type type) : primary{type} {}
        Unit(Type first, Type second) : primary{primary}, secondary(second) {}
        Unit(Type type, uint8_t prec, bool isDecimal = true, bool suffixes = true) :
                primary{type}, precision{prec}, base{isDecimal ? 10.0 : 2.0}, isUnitSuffix{suffixes} {}
        Unit(Type first, Type second, uint8_t prec, bool isDecimal = true) :
                primary{first}, secondary{second}, precision{prec}, base{isDecimal ? 10.0 : 2.0} {}
        Unit(Type first, Type second, Type third, uint8_t prec, bool isDecimal = true) :
                primary{first}, secondary{second}, tertiary{third}, precision{prec}, base{isDecimal ? 10.0 : 2.0} {}
        
        // MARK: - Variables
        
        Type primary;
        std::optional<Type> secondary;
        std::optional<Type> tertiary;
        uint8_t precision = 4;
        double base = 10.0;
        bool isUnitSuffix = true;
        bool isLeadingZero = false;
        
        // MARK: - Functions (const)
        
        bool isDecimal() const {
            return math::isEqual(base, 10.0);   //Base 10 numbers are never displayed as fractions
        }
        double divisor() const {
            return pow(base, static_cast<double>(precision));
        }
        double eps() const {
            return 1.0 / divisor();
        }
        
        bool isMetric(Type type) const {
            return T::metric.at(static_cast<size_t>(type));
        }
        double simpleRatio(double value, double factor, bool reversed) const {
            return value * (reversed ? factor : 1.0 / factor);
        }
        double conversion(Type type, double value, bool reversed = false) const {
                //Values are simply multiplied by a fixed ratio by default (some unit types may override with more complex behaviours)
            return simpleRatio(value, T::conversions.at(static_cast<size_t>(type)), reversed);
        }
        utility::String suffix(Type type) const {
            return T::abbreviations.at(static_cast<size_t>(type));
        }
        std::optional<Type> fromTag(const utility::String& text) const {
            for (auto i = 0; i < T::tags.size(); ++i)
                if (text == T::tags[i])
                    return static_cast<Type>(i);
            return std::nullopt;
        }
        utility::String toTag(Type type) const {
            return T::tags.at(static_cast<size_t>(type));
        }
        std::optional<std::pair<Type, utility::String::size_type>> findSuffix(const utility::String& text,
                                                                              utility::String::size_type startPos = 0) const {
            std::optional<std::pair<Type, utility::String::size_type>> result;
            for (auto i = 0; i < T::abbreviations.size(); ++i) {
                if (auto pos = text.find(T::abbreviations.at(i), startPos); pos && (!result || (*pos < result->second)))
                    result = std::make_pair(static_cast<Type>(i), *pos);
            }
            return result;
        }
    };
    
}
    
#endif //ACTIVE_MEASURE_UNIT