Weather.h

/* Copyright (c) Queen's Printer for Ontario, 2020. */
/* Copyright (c) His Majesty the King in Right of Canada as represented by the Minister of Natural Resources, 2025. */
 
/* SPDX-License-Identifier: AGPL-3.0-or-later */
 
#pragma once
#include "Index.h"
#include "Util.h"
#include "unstable.h"
namespace fs
{
using data::Index;
namespace wx
{
class Temperature : public Index<Temperature>
{
public:
  using Index::Index;
 
  static const Temperature Zero;
  static const Temperature Invalid;
};
class RelativeHumidity : public Index<RelativeHumidity>
{
public:
  using Index::Index;
 
  static const RelativeHumidity Zero;
  static const RelativeHumidity Invalid;
};
class Speed : public Index<Speed>
{
public:
  using Index::Index;
 
  static const Speed Zero;
  static const Speed Invalid;
};
class Direction : public Index<Direction>
{
public:
  ~Direction() = default;
  constexpr Direction() noexcept = default;
  constexpr Direction(const MathSize value, const bool is_radians) noexcept
    : Index(is_radians ? util::to_degrees(value) : value)
  {
  }
  constexpr Direction(const Direction& rhs) noexcept = default;
  constexpr Direction(Direction&& rhs) noexcept = default;
  Direction& operator=(const Direction& rhs) noexcept = default;
  Direction& operator=(Direction&& rhs) noexcept = default;
  [[nodiscard]] constexpr MathSize asRadians() const
  {
    return util::to_radians(asDegrees());
  }
  [[nodiscard]] constexpr MathSize asDegrees() const
  {
    return asValue();
  }
  [[nodiscard]] constexpr MathSize heading() const
  {
    return util::to_heading(asRadians());
  }
  static const Direction Zero;
  static const Direction Invalid;
};
class Wind
{
public:
  ~Wind() = default;
  constexpr Wind() noexcept
    : wsv_x_(0),
      wsv_y_(0),
      direction_(0.0, false),
      speed_(0)
  {
  }
  Wind(const Direction& direction, const Speed speed) noexcept
    : wsv_x_(speed.asValue() * _sin(direction.heading())),
      wsv_y_(speed.asValue() * _cos(direction.heading())),
      direction_(direction),
      speed_(speed)
  {
  }
  constexpr Wind(const Wind& rhs) noexcept = default;
  constexpr Wind(Wind&& rhs) noexcept = default;
  Wind& operator=(const Wind& rhs) noexcept = default;
  Wind& operator=(Wind&& rhs) noexcept = default;
  [[nodiscard]] constexpr const Speed& speed() const noexcept
  {
    return speed_;
  }
  [[nodiscard]] constexpr const Direction& direction() const noexcept
  {
    return direction_;
  }
  [[nodiscard]] constexpr MathSize heading() const noexcept
  {
    return direction_.heading();
  }
  [[nodiscard]] constexpr MathSize wsvX() const noexcept
  {
    return wsv_x_;
  }
  [[nodiscard]] constexpr MathSize wsvY() const noexcept
  {
    return wsv_y_;
  }
  [[nodiscard]] constexpr bool operator!=(const Wind& rhs) const noexcept
  {
    return direction_ != rhs.direction_ || speed_ != rhs.speed_;
  }
  [[nodiscard]] constexpr bool operator==(const Wind& rhs) const noexcept
  {
    return direction_ == rhs.direction_ && speed_ == rhs.speed_;
  }
  [[nodiscard]] constexpr bool operator<(const Wind& rhs) const noexcept
  {
    if (direction_ == rhs.direction_)
    {
      return speed_ < rhs.speed_;
    }
    return direction_ < rhs.direction_;
  }
  [[maybe_unused]] static const Wind Zero;
  static const Wind Invalid;
private:
  MathSize wsv_x_;
  MathSize wsv_y_;
  Direction direction_;
  Speed speed_;
};
class Precipitation : public Index<Precipitation>
{
public:
  using Index::Index;
 
  static const Precipitation Zero;
  static const Precipitation Invalid;
};
class Weather
{
public:
  virtual ~Weather() = default;
  constexpr Weather() noexcept = default;
  constexpr Weather(const Temperature& temp,
                    const RelativeHumidity& rh,
                    const Wind& wind,
                    const Precipitation& prec) noexcept
    : temp_(temp), rh_(rh), wind_(wind), prec_(prec)
  {
  }
  constexpr Weather(Weather&& rhs) noexcept = default;
  constexpr Weather(const Weather& rhs) noexcept = default;
  Weather& operator=(Weather&& rhs) noexcept = default;
  Weather& operator=(const Weather& rhs) = default;
  [[nodiscard]] constexpr const Temperature& temp() const noexcept
  {
    return temp_;
  }
  [[nodiscard]] constexpr const RelativeHumidity& rh() const noexcept
  {
    return rh_;
  }
  [[nodiscard]] constexpr const Wind& wind() const noexcept
  {
    return wind_;
  }
  [[nodiscard]] constexpr const Precipitation& prec() const noexcept
  {
    return prec_;
  }
private:
  Temperature temp_;
  RelativeHumidity rh_;
  Wind wind_;
  Precipitation prec_;
};
}
}