UnitManager.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/Unit.h>
#include <NDEVR/SoftwareService.h>
#include <NDEVR/Resource.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/TranslatedString.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/INIInterface.h>
namespace NDEVR
{
    class INIFactory;
    /**--------------------------------------------------------------------------------------------------
    \brief A definition of how to describe a particular set of data to a custom category of unit. 
    **/
    class NDEVR_BASE_API UnitOption
    {
    public:
        UnitOption(const String& id, const TranslatedString& name)
            : name(name)
            , id(id)
        {}
        virtual ~UnitOption() {};
        virtual TranslatedString title() const { return name; };
        virtual ConstPointer<Unit> unit() const = 0;
        virtual bool hasMemberUnit(const ConstPointer<Unit>& unit) const = 0;
        virtual ConstPointer<Unit> unit(const ConstPointer<Unit>&) const { return unit(); };
        virtual Buffer<ConstPointer<UnitOption>> subOptions() const { return Buffer<ConstPointer<UnitOption>>(); };
 
 
        TranslatedString name;
        String id;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A definition of how to describe a particular set of data to a custom category of unit.
    **/
    class NDEVR_BASE_API BasicUnitOption : public UnitOption
    {
    public:
        BasicUnitOption(const ConstPointer<Unit>& unit, const TranslatedString& custom_title = TranslatedString())
            : UnitOption(unit->name, unit->translatedName())
            , base_unit(unit)
            , custom_title(custom_title)
        {}
        virtual TranslatedString title() const final override;
        virtual bool hasMemberUnit(const ConstPointer<Unit>& unit) const final override;
        virtual ConstPointer<Unit> unit() const final override { return base_unit; };
        virtual Buffer<ConstPointer<UnitOption>> subOptions() const final override { return m_sub_options; };
        virtual Buffer<ConstPointer<UnitOption>>& editSubOptions() { return m_sub_options; };
        ConstPointer<Unit> base_unit;
        TranslatedString custom_title;
    protected:
        Buffer<ConstPointer<UnitOption>> m_sub_options;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A definition of how to describe coordinate data
    **/
    class NDEVR_BASE_API CoordinateUnitOption : public UnitOption
    {
    public:
        CoordinateUnitOption(const String& id, const TranslatedString& name)
            : UnitOption(id, name)
        {}
        virtual ConstPointer<Unit> unit() const final override;
        virtual bool hasMemberUnit(const ConstPointer<Unit>& unit) const final override;
        virtual ConstPointer<Unit> unit(const ConstPointer<Unit>& distance_unit) const final override;
    };
    class UnitManager;
    /**--------------------------------------------------------------------------------------------------
    Class: BaseValues
    \brief A program-defined unit that can be used for some specific task different from a program-wide unit.
    **/
    class NDEVR_BASE_API CustomUnit
    {
    public:
        CustomUnit(const String& id, const TranslatedString& name, UnitCategory unit_type)
            : name(name)
            , id(id)
            , unit_type(unit_type)
        {}
        virtual ~CustomUnit() {};
        TranslatedString name;
        String id;
        UnitCategory unit_type;
        [[nodiscard]] virtual TranslatedString title() const { return name; };
        [[nodiscard]] virtual Resource<ConstPointer<Unit>>& unitResource(UnitManager& manager) = 0;
        [[nodiscard]] virtual Buffer<ConstPointer<UnitOption>> options( UnitManager& manager) const = 0;
        virtual void prepareForINI(const UnitManager&) {};
        virtual void setupINI(INIFactory&) = 0;
        virtual void resetToDefault( UnitManager&);
        virtual void finishReadingINI( UnitManager&) {};
        virtual ConstPointer<Unit> currentUnit();
        virtual ConstPointer<Unit> currentUnit( UnitManager& manager);
        [[nodiscard]] virtual ConstPointer<Unit> defaultUnit( UnitManager&) const = 0;
    };
    /**--------------------------------------------------------------------------------------------------
    Class: BaseValues
    \brief A unit that mirrors another set unit
    **/
    class NDEVR_BASE_API ReferenceCustomUnit : public CustomUnit
    {
    public:
        ReferenceCustomUnit(const String& id, const TranslatedString& name, UnitCategory unit_type)
            : CustomUnit(id, name, unit_type)
        {}
        virtual ~ReferenceCustomUnit() {};
        [[nodiscard]] virtual Resource<ConstPointer<Unit>>& unitResource(UnitManager& manager) override;
        [[nodiscard]] virtual Buffer<ConstPointer<UnitOption>> options( UnitManager& manager) const override;
        virtual void prepareForINI(const UnitManager&) override{}
        virtual void setupINI(INIFactory&) override {};
        virtual void resetToDefault( UnitManager&) override;
        virtual void finishReadingINI( UnitManager&) override {};
        virtual ConstPointer<Unit> currentUnit( UnitManager& manager) override;
        [[nodiscard]] virtual ConstPointer<Unit> defaultUnit( UnitManager&) const override;
    };
    /**--------------------------------------------------------------------------------------------------
    Class: BaseValues
    \brief A program-defined unit that can be used for some specific task different from a program-wide unit.
    **/
    class NDEVR_BASE_API BasicCustomUnit : public CustomUnit
    {
    public:
        BasicCustomUnit(const String& name, const TranslatedString& title, UnitCategory type);
        virtual void prepareForINI(const UnitManager& manager) override;
        virtual void setupINI(INIFactory& ini) override;
        virtual void finishReadingINI(UnitManager& manager) override;
        [[nodiscard]] virtual TranslatedString title() const override { return m_title; };
        [[nodiscard]] virtual Resource<ConstPointer<Unit>>& unitResource(UnitManager& manager) override;
        [[nodiscard]] Buffer<ConstPointer<UnitOption>> options(UnitManager& manager) const override;
        [[nodiscard]] virtual ConstPointer<Unit> defaultUnit(UnitManager&) const override;
    protected:
        TranslatedString m_title;
        String m_ini_unit_name;
        Resource<ConstPointer<Unit>> m_unit;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Handles a grouping of units that can describe any number of data categories.
    **/
    class NDEVR_BASE_API UnitManager : public INIInterface, public SoftwareServiceManager
    {
    public:
        UnitManager();
        UnitManager(const UnitManager& manager);
        ~UnitManager();
        void setToDefaultMetric(bool preserve_spacial);
        void setToDefaultImperial(bool preserve_spacial);
        void tieToManager(const UnitManager& manager);
        void getINI(INIFactory& factory) override;
        void prepareForINI(INIFactory& factory) override;
        void finishReadingINI(INIFactory& factory) override;
        void updateCoordinateBase(const ConstPointer<Unit>& base);
        [[nodiscard]] static UnitManager& DefaultManager();
 
        [[nodiscard]] ConstPointer<Unit> unit(UnitCategory type) const;
        [[nodiscard]] ConstPointer<Unit> orientationOffsetUnit() const;
        [[nodiscard]] Resource<ConstPointer<Unit>>& unitResource(UnitCategory type);
        void setUnit(UnitCategory type, const ConstPointer<Unit>& unit);
        void clearUnitOptions(UnitCategory type);
        void setUnitOptionsToDefault(UnitCategory type);
        void setUnitOptions(UnitCategory type, const Buffer<ConstPointer<UnitOption>>& options);
        void setUnitOptions(UnitCategory type, const Buffer<ConstPointer<Unit>>& options);
 
        [[nodiscard]] Buffer<ConstPointer<UnitOption>> unitOptions(UnitCategory units) const;
        [[nodiscard]] const Buffer<ConstPointer<UnitOption>>& angleUnitOptions() const { return m_angle_unit_options; };
        [[nodiscard]] const Buffer<ConstPointer<UnitOption>>& latLonUnitOptions() const { return m_lat_lon_unit_options; };
        [[nodiscard]] const Buffer<ConstPointer<UnitOption>>& distanceUnitOptions() const { return m_distance_unit_options; };
        [[nodiscard]] const Buffer<ConstPointer<UnitOption>>& areaUnitOptions() const { return m_area_unit_options; };
        [[nodiscard]] const Buffer<ConstPointer<UnitOption>>& volumeUnitOptions() const { return m_volume_unit_options; };
        [[nodiscard]] const Buffer<ConstPointer<UnitOption>>& weightUnitOptions() const { return m_weight_unit_options; };
        [[nodiscard]] const Buffer<ConstPointer<UnitOption>>& coordinateSpaceFormatOptions() const { return m_coordinate_format_options; }
        [[nodiscard]] const Buffer<DynamicPointer<CustomUnit>>& specialUnits() const { return m_special_units; }
        void addSpecialUnit(const DynamicPointer<CustomUnit>& custom_unit);
        ConstPointer<Unit> specialUnit(const String& name);
        Resource<ConstPointer<Unit>>& specialUnitResource(const String& name);
        bool hasSpecialUnit(const String& name) const;
        void setupDefaultAngleUnitOptions();
        void setupDefaultDistanceOptions();
        void setupDefaultCoordinateSpaceOptions();
        void setupDefaultVolumeOptions();
        void setupDefaultAreaOptions();
        void setupDefaultWeightOptions();
        void setupDefaultLatLonOptions();
        [[nodiscard]] ConstPointer<Unit> unit(const String& name) const;
 
 
        [[nodiscard]] ConstPointer<Unit> parseUnit(const String& name, UnitCategory type = UnitCategory::e_undefined_unit) const;
        [[nodiscard]] ConstPointer<Unit> determineUnit(const Buffer<String>& unit_parts, UnitCategory type) const;
 
        bool canBeImperial(const ConstPointer<Unit>& unit) const;
        bool canBeMetric(const ConstPointer<Unit>& unit) const;
        void addFormatOption(UnitCategory unit_type, const ConstPointer<UnitOption>& format_option);
        void removeFormatOption(UnitCategory unit_type, const ConstPointer<UnitOption>& format_option);
        [[nodiscard]] static ConstPointer<UnitOption> ActiveOption(const Buffer<ConstPointer<UnitOption>>& options, const ConstPointer<Unit>& unit);
        UnitManager& operator=(const UnitManager& manager);
    public:
        Resource<ConstPointer<Unit>> angle_unit;//unit for describing non-dimensional angles
        Resource<ConstPointer<Unit>> orientation_space_unit;//unit for describing dimensional angles
        Resource<ConstPointer<Unit>> distance_unit;//unit for describing non-dimensional distances
        Resource<ConstPointer<Unit>> coordinate_space_unit;//unit for describing dimensional distances
        Resource<ConstPointer<Unit>> surface_area_unit;//unit for describing surface areas
        Resource<ConstPointer<Unit>> volume_unit;//unit for describing volumes
        Resource<ConstPointer<Unit>> weight_unit;//unit for describing weights
        Resource<ConstPointer<Unit>> temperature_unit;//unit for describing temperature
        Resource<ConstPointer<Unit>> lat_lon_unit;//unit for describing position on globe
        static Resource<ConstPointer<Unit>> default_orientation_space_unit;//default program-wide unit for describing non-dimensional angles
    protected:
        Buffer<ConstPointer<UnitOption>> m_angle_unit_options;//all units that are specified for describing non-dimensional angles
        Buffer<ConstPointer<UnitOption>> m_lat_lon_unit_options;//all units that are specified for describing position on globe
        Buffer<ConstPointer<UnitOption>> m_distance_unit_options;//all units that are specified for describing non-dimensional distances
        Buffer<ConstPointer<UnitOption>> m_area_unit_options;//all units that are specified for describing surface areas
        Buffer<ConstPointer<UnitOption>> m_volume_unit_options;//all units that are specified for describing volumes
        Buffer<ConstPointer<UnitOption>> m_weight_unit_options;//all units that are specified for describing weights
        Buffer<ConstPointer<UnitOption>> m_coordinate_format_options;//all units that are specified for describing dimensional distances
        Dictionary<String, ConstPointer<UnitOption>> m_registered_units;//all registered units
        Buffer<DynamicPointer<CustomUnit>> m_special_units;
        Dictionary<String, DynamicPointer<CustomUnit>> m_special_unit_lookup;
    private:
        //For INI read/writes
        String angle_name;
        String orientation_space_name;
        String coordinate_space_name;
        String distance_space_name;
        String surface_area_name;
        String volume_name;
        String temperature_name;
        String weight_name;
        String lat_lon_name;
    protected:
        ResourceListener* m_tie_to_listener = nullptr;
    };
}