unit.h

Go to the documentation of this file.

// === unit.h ==========================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_META_UNIT_H
#define SEN_CORE_META_UNIT_H
 
// sen
#include "sen/core/base/class_helpers.h"
#include "sen/core/base/hash32.h"
#include "sen/core/base/numbers.h"
#include "sen/core/meta/type.h"
 
// std
#include <memory>
#include <string>
#include <string_view>
 
namespace sen
{


enum class UnitCategory
{
  // Base measurements
  length,
  mass,  // Note: Base unit is gram (g), not kilogram (kg). This keeps internal consistency with density (g/cm3), though
         // it differs from the SI-canonical base (kg)
  time,
  angle,
  temperature,
  density,
  pressure,
  area,
  force,
 
  // Derived measurements
  frequency,
  velocity,
  angularVelocity,
  acceleration,
  angularAcceleration,
  torque
};

struct UnitSpec
{
  // Comparison operators
  friend bool operator==(const UnitSpec& lhs, const UnitSpec& rhs) noexcept
  {
    return lhs.category == rhs.category && lhs.name == rhs.name && lhs.namePlural == rhs.namePlural &&
           lhs.abbreviation == rhs.abbreviation && lhs.f == rhs.f && lhs.x == rhs.x && lhs.y == rhs.y;
  }
 
  friend bool operator!=(const UnitSpec& lhs, const UnitSpec& rhs) noexcept { return !(lhs == rhs); }
 
public:
  UnitCategory category;     
  std::string name;          
  std::string namePlural;    
  std::string abbreviation;  
  float64_t f;               
  float64_t x;               
  float64_t y;               
};

class Unit
{
  SEN_COPY_MOVE(Unit)
  SEN_PRIVATE_TAG
 
public:
  Unit(UnitSpec spec, Private notUsable) noexcept;
  ~Unit() noexcept = default;
 
public:
  static std::unique_ptr<Unit> make(UnitSpec spec);
 
  struct EnsureTag
  {
  };

  static constexpr inline EnsureTag ensurePresent {};
 
public:
  [[nodiscard]] UnitCategory getCategory() const noexcept;

  [[nodiscard]] std::string_view getName() const noexcept;

  [[nodiscard]] std::string_view getNamePlural() const noexcept;

  [[nodiscard]] std::string_view getAbbreviation() const noexcept;

  [[nodiscard]] float64_t toSI(float64_t value) const noexcept;

  [[nodiscard]] float64_t fromSI(float64_t value) const noexcept;

  [[nodiscard]] Result<float64_t, std::string> fromString(const std::string& str) const noexcept;

  [[nodiscard]] static float64_t convert(const Unit& from, const Unit& to, float64_t value) noexcept;

  [[nodiscard]] static std::string_view getCategoryString(UnitCategory category) noexcept;

  [[nodiscard]] MemberHash getHash() const noexcept;
 
public:  
  [[nodiscard]] bool operator==(const Unit& other) const noexcept;
  [[nodiscard]] bool operator!=(const Unit& other) const noexcept;
 
private:
  UnitSpec spec_;
  MemberHash hash_;
};

 
//----------------------------------------------------------------------------------------------------------------------
// Inline implementation
//----------------------------------------------------------------------------------------------------------------------

template <>
struct impl::hash<UnitSpec>
{
  u32 operator()(const UnitSpec& spec) const noexcept
  {
    return hashCombine(hashSeed, spec.category, spec.name, spec.namePlural, spec.abbreviation, spec.f, spec.x, spec.y);
  }
};
 
}  // namespace sen
 
#endif  // SEN_CORE_META_UNIT_H