Util.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, 2021-2025. */
 
/* SPDX-License-Identifier: AGPL-3.0-or-later */
 
#pragma once
#include "stdafx.h"
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#ifndef TIFFTAG_GDAL_NODATA
#define TIFFTAG_GDAL_NODATA 42113
#endif
 
TIFF* GeoTiffOpen(const char* const filename, const char* const mode);
 
int sxprintf(char* buffer, size_t N, const char* format, va_list* args);
int sxprintf(char* buffer, size_t N, const char* format, ...);
template <std::size_t N>
int sxprintf(char (&buffer)[N], const char* format, va_list* args)
{
  // printf("int sxprintf(char (&buffer)[N], const char* format, va_list* args)\n");
  return sxprintf(&buffer[0], N, format, args);
}
template <std::size_t N>
int sxprintf(char (&buffer)[N], const char* format, ...)
{
  // printf("int sxprintf(char (&buffer)[N], const char* format, ...)\n");
  va_list args;
  va_start(args, format);
  auto r = sxprintf(buffer, format, &args);
  va_end(args);
  return r;
}
 
namespace fs
{
namespace util
{
template <typename T>
[[nodiscard]] DurationSize to_time(const T day, const int hour) noexcept
{
  return day + hour / (1.0 * DAY_HOURS);
}
[[nodiscard]] constexpr DurationSize to_time(const size_t t_index) noexcept
{
  return static_cast<DurationSize>(t_index) / DAY_HOURS;
}
template <typename T>
[[nodiscard]] size_t time_index(const T day, const int hour) noexcept
{
  return static_cast<size_t>(day) * DAY_HOURS + hour;
}
template <typename T>
[[nodiscard]] size_t time_index(const T day,
                                const int hour,
                                const Day min_date) noexcept
{
  return time_index(day, hour) - static_cast<size_t>(DAY_HOURS) * min_date;
}
[[nodiscard]] constexpr size_t time_index(const DurationSize time) noexcept
{
  return static_cast<size_t>(time * DAY_HOURS);
}
[[nodiscard]] constexpr size_t time_index(const DurationSize time,
                                          const Day min_date) noexcept
{
  return time_index(time) - static_cast<size_t>(DAY_HOURS) * min_date;
}
template <class T>
[[nodiscard]] T no_convert(int value, int) noexcept
{
  return static_cast<T>(value);
}
[[nodiscard]] constexpr MathSize fix_radians(const MathSize theta)
{
  if (theta > M_2_X_PI)
  {
    return theta - M_2_X_PI;
  }
  if (theta < 0)
  {
    return theta + M_2_X_PI;
  }
  return theta;
}
[[nodiscard]] constexpr MathSize to_radians(const MathSize degrees) noexcept
{
  return fix_radians(degrees / M_RADIANS_TO_DEGREES);
}
// only calculate this once and reuse it
static constexpr MathSize RAD_360 = to_radians(360);
static constexpr MathSize RAD_270 = to_radians(270);
static constexpr MathSize RAD_180 = to_radians(180);
static constexpr MathSize RAD_090 = to_radians(90);
[[nodiscard]] constexpr MathSize to_degrees(const MathSize radians)
{
  return fix_radians(radians) * M_RADIANS_TO_DEGREES;
}
[[nodiscard]] constexpr MathSize to_heading(const MathSize azimuth)
{
  return fix_radians(azimuth + RAD_180);
}
template <class Elem,
          class Traits,
          class Alloc>
std::basic_istream<Elem, Traits>& getline(
  std::basic_istream<Elem, Traits>* stream,
  std::basic_string<Elem, Traits, Alloc>* str,
  const Elem delimiter)
{
  // make template so we can use pointers directly
  return getline(*stream, *str, delimiter);
}
[[nodiscard]] bool directory_exists(const char* dir) noexcept;
[[nodiscard]] bool file_exists(const char* path) noexcept;
void read_directory(const bool for_files,
                    const string& name,
                    vector<string>* v,
                    const string& match);
void read_directory(const string& name,
                    vector<string>* v,
                    const string& match);
void read_directory(const bool for_files,
                    const string& name,
                    vector<string>* v);
void read_directory(const string& name, vector<string>* v);
[[nodiscard]] vector<string> find_rasters(const string& dir, int year);
void make_directory(const char* dir) noexcept;
void make_directory_recursive(const char* dir) noexcept;
template <class T>
[[nodiscard]] inline constexpr MathSize sq(const T& x)
{
  return static_cast<MathSize>(x) * static_cast<MathSize>(x);
}
template <unsigned int N, class T>
[[nodiscard]] constexpr T pow_int(const T& base)
{
  // https://stackoverflow.com/questions/16443682/c-power-of-integer-template-meta-programming
  return N == 0
         ? 1
       : N % 2 == 0
         ? pow_int<N / 2, T>(base) * pow_int<N / 2, T>(base)
         : base * pow_int<(N - 1) / 2, T>(base) * pow_int<(N - 1) / 2, T>(base);
}
template <unsigned int N, class T>
[[nodiscard]] constexpr T bit_mask()
{
  return static_cast<T>(pow_int<N, int64_t>(2) - 1);
}
template <unsigned int N>
[[nodiscard]] MathSize round_to_precision(const MathSize value) noexcept
{
  // HACK: this can't actually make the value be the precision we want due to
  // floating point storage, but we can round it to what it would be if it were
  // that precision
  static const auto b = pow_int<N, int64_t>(10);
  return round(value * b) / b;
}
tm to_tm(const int year,
         const int month,
         const int day,
         const int hour,
         const int minute);
DurationSize to_time(const tm& t);
DurationSize to_time(const int year,
                     const int month,
                     const int day,
                     const int hour,
                     const int minute);
void read_date(istringstream* iss, string* str, tm* t);
class UsageCount
{
  atomic<size_t> count_;
  string for_what_;
public:
  ~UsageCount();
  explicit UsageCount(string for_what) noexcept;
  UsageCount(UsageCount&& rhs) noexcept = delete;
  UsageCount(const UsageCount& rhs) noexcept = delete;
  UsageCount& operator=(UsageCount&& rhs) noexcept = delete;
  UsageCount& operator=(const UsageCount& rhs) noexcept = delete;
  UsageCount& operator++() noexcept;
};
// https://stackoverflow.com/questions/15843525/how-do-you-insert-the-value-in-a-sorted-vector
template <typename T>
[[nodiscard]] typename std::vector<T>::iterator
  insert_sorted(std::vector<T>* vec, T const& item)
{
  return vec->insert(std::upper_bound(vec->begin(), vec->end(), item), item);
}
template <typename T>
void insert_unique(std::vector<T>* vec, T const& item)
{
  const auto i = std::lower_bound(vec->begin(), vec->end(), item);
  if (i == vec->end() || *i != item)
  {
    vec->insert(i, item);
  }
}
}
template <typename T, typename V>
T binary_find(const T lower,
              const T upper,
              const MathSize value,
              const std::function<V(T)>& fct)
{
  const auto mid = lower + (upper - lower) / 2;
  if (lower == upper)
  {
    return lower;
  }
  if (fct(mid) < value)
  {
    return binary_find(lower, mid, value, fct);
  }
  return binary_find(mid + 1, upper, value, fct);
}
template <typename T, typename V>
T binary_find_checked(const T lower,
                      const T upper,
                      const MathSize value,
                      const std::function<V(T)>& fct)
{
  if (fct(lower) < value)
  {
    return lower;
  }
  if (fct(upper) >= value)
  {
    return upper;
  }
  return binary_find(lower, upper, value, fct);
}
void month_and_day(const int year, const size_t day_of_year, size_t* month, size_t* day_of_month);
[[nodiscard]] bool is_leap_year(const int year);
[[nodiscard]] string make_timestamp(const int year, const DurationSize time);
[[nodiscard]] inline MathSize ellipse_angle(const MathSize length_to_breadth,
                                            const MathSize theta)
{
  return (util::fix_radians(
    atan2(sin(theta) / length_to_breadth,
          cos(theta))));
}
}