datamodel_units.h

Go to the documentation of this file.

 
#ifndef DD_DATA_MODEL_UNITS_H_INCLUDED
#define DD_DATA_MODEL_UNITS_H_INCLUDED
 
#include <ddl/dd/datamodel/datamodel_base.h>
#include <ddl/dd/dd_common_types.h>
#include <ddl/utilities/access_list.h>
#include <ddl/utilities/access_map.h>
#include <ddl/utilities/access_observer.h>
#include <ddl/utilities/infomodel_base.h>
 
#include <string>
#include <vector>
 
namespace ddl {
 
namespace dd {
 
namespace datamodel {
class UnitBase {
public:
    UnitBase() = default;
    UnitBase(const UnitBase&) = default;
    UnitBase(UnitBase&&) = default;
    UnitBase& operator=(const UnitBase&) = default;
    UnitBase& operator=(UnitBase&&) = default;
    UnitBase(std::string name);
    virtual ~UnitBase() = default;
    virtual TypeOfUnit getTypeOfUnit() const = 0;
    virtual void setName(const std::string& name);
    const std::string& getName() const;
 
protected:
    std::string _name;
};

class BaseUnit : public UnitBase,
                 public ModelSubject<BaseUnit>,
                 public utility::TypeAccessMapSubject<BaseUnit>,
                 public InfoMap {
public:
    BaseUnit(){};
    BaseUnit(const BaseUnit&) = default;
    BaseUnit(BaseUnit&&) = default;
    BaseUnit& operator=(const BaseUnit&) = default;
    BaseUnit& operator=(BaseUnit&&) = default;
    BaseUnit(std::string name,
             std::string symbol,
             std::string description = {});
    virtual ~BaseUnit() = default;
 
    TypeOfUnit getTypeOfUnit() const override;
    void setName(const std::string& name) override;

    const std::string& getSymbol() const;
    void setSymbol(const std::string& symbol);

    const std::string& getDescription() const;
    void setDescription(const std::string& description);

    bool operator==(const BaseUnit& other) const;
    bool operator!=(const BaseUnit& other) const;
 
private:
    void notify(const std::string& additional_info);
    std::string _symbol = {};
    std::string _description = {};
};

class UnitPrefix : public ModelSubject<UnitPrefix>,
                   public utility::TypeAccessMapSubject<UnitPrefix>,
                   public InfoMap {
public:
    UnitPrefix(){};
    UnitPrefix(const UnitPrefix&) = default;
    UnitPrefix(UnitPrefix&&) = default;
    UnitPrefix& operator=(const UnitPrefix&) = default;
    UnitPrefix& operator=(UnitPrefix&&) = default;
    UnitPrefix(std::string name, std::string symbol, int32_t power);
    virtual ~UnitPrefix() = default;

    const std::string& getName() const;
    void setName(const std::string& name);

    const std::string& getSymbol() const;
    void setSymbol(const std::string& symbol);

    int32_t getPower() const;
    void setPower(int32_t power);
    bool operator==(const UnitPrefix& other) const;
    bool operator!=(const UnitPrefix& other) const;
 
private:
    void notify(const std::string& additional_info);
    std::string _name = {};
    std::string _symbol = {};
    int32_t _power = {};
};

class Unit : public UnitBase,
             public ModelSubject<Unit>,
             public utility::TypeAccessMapSubject<Unit>,
             public InfoMap {
public:
    Unit();
    Unit(const Unit&) = default;
    Unit& operator=(const Unit&) = default;
    Unit(Unit&&) = default;
    Unit& operator=(Unit&&) = default;
    virtual ~Unit() = default;

    class RefUnit {
    public:
        RefUnit(){};
        RefUnit(const RefUnit&) = default;
        RefUnit(RefUnit&&) = default;
        RefUnit& operator=(const RefUnit&) = default;
        RefUnit& operator=(RefUnit&&) = default;
        RefUnit(std::string unit_name, int32_t power, std::string prefix_name);
        bool operator==(const RefUnit& other) const;
        bool operator!=(const RefUnit& other) const;

        const std::string& getUnitName() const;
        int32_t getPower() const;
        const std::string& getPrefixName() const;
 
    private:
        std::string _unit_name = {};
        int32_t _power = {};
        std::string _prefix_name = {};
    };

    Unit(std::string name,
         std::string numerator,
         std::string denominator,
         std::string offset,
         const std::vector<RefUnit>& ref_units = {});
    bool operator==(const Unit& other) const;
    bool operator!=(const Unit& other) const;

    TypeOfUnit getTypeOfUnit() const override;
    void setName(const std::string& name) override;
    const std::string& getNumerator() const;
    void setNumerator(const std::string& numerator);

    const std::string& getDenominator() const;
    void setDenominator(const std::string& denominator);

    const std::string& getOffset() const;
    void setOffset(const std::string& offset);
 
public:
    using RefUnits = std::vector<RefUnit>;
    const RefUnits& getRefUnits() const;

    void addRefUnit(const RefUnit& ref_unit);
    void removeRefUnit(const RefUnit& ref_unit);
 
private:
    void notify(ModelEventCode code,
                utility::TypeAccessMapEventCode map_code,
                const std::string& additional_info);
 
private:
    std::string _numerator = {};
    std::string _denominator = {};
    std::string _offset = {};
    RefUnits _ref_units;
};
 
} // namespace datamodel
} // namespace dd
} // namespace ddl
 
#endif // DD_DATA_MODEL_UNITS_H_INCLUDED