Unit.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/TranslatedString.h>
#include <NDEVR/StringStream.h>
#include <NDEVR/Angle.h>
namespace NDEVR
{
    class TranslatedString;
    /**--------------------------------------------------------------------------------------------------
    \brief A category of unit describing what it relates to. Any category can have some number of units
        defined which could be used to display or describe the data. 
    **/
    enum class UnitCategory
    {
          e_undefined_unit
        , e_angle
        , e_orientation
        , e_distance
        , e_coordinate
        , e_surface_area
        , e_volume
        , e_weight
        , e_speed
        , e_acceleration
        , e_rotational_speed
        , e_time
        , e_force
        , e_ratio
        , e_lat_lon
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A definition of how to describe and display data. Units can be of any type.
    **/
    struct NDEVR_BASE_API Unit
    {
        const String name;
        const TranslatedString translated_id;
        TranslatedString axis_name_ids[4];
        TranslatedString axis_abbreviations[4];
        Unit(String name, TranslatedString translated_id);
        virtual ~Unit() = default;
 
        [[nodiscard]] virtual fltp08 convertToUnit(const fltp08& program_space, const uint01 direction = X) const = 0;
        [[nodiscard]] virtual fltp08 convertFromUnit(const fltp08& unit_space, const uint01 direction = X) const = 0;
        [[nodiscard]] virtual Vertex<3, fltp08> convertToUnit(const Vertex<3, fltp08>& program_space) const = 0;
        [[nodiscard]] virtual Vertex<3, fltp08> convertFromUnit(const Vertex<3, fltp08>& unit_space) const = 0;
        [[nodiscard]] virtual Ray<3, fltp08> convertToUnit(const Ray<3, fltp08>& program_space) const = 0;
        [[nodiscard]] virtual Ray<3, fltp08> convertFromUnit(const Ray<3, fltp08>& unit_space) const = 0;
        [[nodiscard]] virtual const TranslatedString& abbreviation(uint01 direction = X) const = 0;
        template<class t_angle_type>
        [[nodiscard]] String convertToString(const Angle<t_angle_type>& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            return convertToString(program_space.template internal<false>(), add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
        }
        template<class t_angle_type>
        [[nodiscard]] fltp08 convertToUnit(const Angle<t_angle_type>& program_space, uint01 direction = X) const
        {
            return convertToUnit(program_space.template internal<false>(), direction);
        }
        template<class t_angle_type>
        [[nodiscard]] Angle<t_angle_type> convertAngleFromUnit(const fltp08& unit_space, uint01 direction = X) const
        {
            return Angle<t_angle_type>(INTERNAL_ANGLE, convertFromUnit(unit_space, direction));
        }
        [[nodiscard]] virtual String convertToString(const fltp08& program_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            return toString(convertToUnit(program_space, direction), add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
        }
        [[nodiscard]] String toString(const fltp08& unit_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            String s;
            toString(s, unit_space, add_comma, min_decimals, max_decimals, min_digits, include_abv, direction);
            return s;
        }
 
        virtual void toString(String& string, const fltp08& unit_space, bool add_comma, uint04 min_decimals, uint04 max_decimals, uint04 min_digits, bool include_abv = true, uint01 direction = X) const
        {
            StringStream<fltp08>::toString(unit_space, string);
            if (add_comma || min_decimals > 0 || max_decimals <= string.size() || min_digits > 0)
                string = string.formatNumberString(add_comma, min_decimals, max_decimals, min_digits);
            if (include_abv)
                string += abbreviation(direction).translation();
        }
 
        [[nodiscard]] virtual fltp08 convertFromString(const String& unit_string, uint01 direction = X) const
        {
            return convertFromUnit(fromString(unit_string, direction), direction);
        }
        [[nodiscard]] virtual fltp08 fromString(const String& unit_string, uint01 direction = X) const
        {
            UNUSED(direction);
            return unit_string.getAs<fltp08>();
        }
 
        [[nodiscard]] TranslatedString translatedName() const;
        [[nodiscard]] virtual TranslatedString translatedAxisName(uint04 index) const;
        [[nodiscard]] virtual String getNextPreferredSeparator(const String& current_string, uint01 direction = X) const;
 
        [[nodiscard]] virtual String toFormula(const String& unit_string, uint01 direction = X) const;
        [[nodiscard]] virtual fltp08 epsilon(fltp08 value, uint01 direction = X) const;
 
 
        [[nodiscard]] virtual const Unit* subUnit(uint01 direction) const = 0;
        [[nodiscard]] virtual Matrix<fltp08> matrix() const = 0;
        bool operator==(const Unit& other) const
        {
            return other.matrix() == matrix() && other.name == name;
        }
        [[nodiscard]] virtual Unit* clone() const;
        [[nodiscard]] virtual Unit* clone(const String& new_name, const TranslatedString& new_display_name) const = 0;
    protected:
        static Buffer<String> OperatorSplit(const String& string);
    };
    template class NDEVR_BASE_API StringStream<UnitCategory>;
 
 
}