types.h

Go to the documentation of this file.

#ifndef DBALLE_TYPES_H
#define DBALLE_TYPES_H

 
#include <dballe/fwd.h>
#include <functional>
#include <iosfwd>
#include <memory>
#include <wreport/varinfo.h>
 
namespace wreport {
class Var;
}
 
namespace dballe {
struct CSVWriter;

struct Date
{
    unsigned short year;
    unsigned char month;
    unsigned char day;

    Date();

    Date(int ye, int mo = 1, int da = 1);

    Date(const Date& d) = default;

    static Date from_julian(int jday);

    bool is_missing() const;

    int to_julian() const;

    void to_stream_iso8601(std::ostream& out) const;

    void to_csv_iso8601(CSVWriter& out) const;

    int compare(const Date& other) const;
 
    bool operator<(const Date& dt) const;
    bool operator>(const Date& dt) const;
    bool operator==(const Date& dt) const;
    bool operator!=(const Date& dt) const;

    static void validate(int ye, int mo, int da);
    static int days_in_month(int year, int month);
    static int calendar_to_julian(int year, int month, int day);
    static void julian_to_calendar(int jday, unsigned short& year,
                                   unsigned char& month, unsigned char& day);
};
 
std::ostream& operator<<(std::ostream& out, const Date& dt);

struct Time
{
    unsigned char hour;
    unsigned char minute;
    unsigned char second;

    Time();

    Time(int ho, int mi = 0, int se = 0);
 
    Time(const Time& t) = default;

    bool is_missing() const;

    void to_stream_iso8601(std::ostream& out) const;

    void to_csv_iso8601(CSVWriter& out) const;

    int compare(const Time& other) const;
 
    bool operator<(const Time& dt) const;
    bool operator>(const Time& dt) const;
    bool operator==(const Time& dt) const;
    bool operator!=(const Time& dt) const;

    static void validate(int ho, int mi, int se);
};
 
std::ostream& operator<<(std::ostream& out, const Time& t);

struct Datetime
{
    unsigned short year;
    unsigned char month;
    unsigned char day;
    unsigned char hour;
    unsigned char minute;
    unsigned char second;

    Datetime();
    Datetime(const Date& date, const Time& time);

    Datetime(int ye, int mo = 1, int da = 1, int ho = 0, int mi = 0,
             int se = 0);

    static Datetime from_julian(int jday, int ho = 0, int mi = 0, int se = 0);

    static Datetime lower_bound(int ye, int mo, int da, int ho, int mi, int se);

    static Datetime upper_bound(int ye, int mo, int da, int ho, int mi, int se);

    void set_lower_bound();

    void set_upper_bound();

    Date date() const;

    Time time() const;

    bool is_missing() const;

    int to_julian() const;

    int compare(const Datetime& other) const;
 
    bool operator==(const Datetime& o) const;
    bool operator!=(const Datetime& o) const;
    bool operator<(const Datetime& o) const;
    bool operator>(const Datetime& o) const;
    bool operator<=(const Datetime& o) const;
    bool operator>=(const Datetime& o) const;

    int print_iso8601(FILE* out, char sep = 'T', const char* end = "\n") const;

    int print(FILE* out, const char* end = "\n") const;

    void to_stream_iso8601(std::ostream& out, char sep = 'T',
                           const char* tz = "") const;

    void to_csv_iso8601(CSVWriter& out, char sep = 'T',
                        const char* tz = "") const;

    std::string to_string(char sep = 'T', const char* tz = "") const;

    static Datetime from_iso8601(const char* str);

    static void validate(int ye, int mo, int da, int ho, int mi, int se);

    static void normalise_h24(int& ye, int& mo, int& da, int& ho, int& mi,
                              int& se);
};
 
std::ostream& operator<<(std::ostream& out, const Datetime& dt);

struct DatetimeRange
{
    Datetime min;
    Datetime max;
 
    DatetimeRange() = default;
    DatetimeRange(const Datetime& min, const Datetime& max) : min(min), max(max)
    {
    }
    DatetimeRange(int yemin, int momin, int damin, int homin, int mimin,
                  int semin, int yemax, int momax, int damax, int homax,
                  int mimax, int semax);

    bool is_missing() const;
 
    bool operator==(const DatetimeRange& o) const;
    bool operator!=(const DatetimeRange& o) const;
    bool operator<(const DatetimeRange& o) const;
    bool operator<=(const DatetimeRange& o) const;
    bool operator>(const DatetimeRange& o) const;
    bool operator>=(const DatetimeRange& o) const;

    void set(const Datetime& min, const Datetime& max);

    void set(int yemin, int momin, int damin, int homin, int mimin, int semin,
             int yemax, int momax, int damax, int homax, int mimax, int semax);

    void merge(const DatetimeRange& range);

    bool contains(const Datetime& dt) const;

    bool contains(const DatetimeRange& dtr) const;

    bool is_disjoint(const DatetimeRange& dtr) const;

    int print(FILE* out, const char* end = "\n") const;
};
 
std::ostream& operator<<(std::ostream& out, const DatetimeRange& dtr);

struct Coords
{
    int lat = MISSING_INT;

    int lon = MISSING_INT;

    Coords() = default;
    Coords(int lat, int lon);
    Coords(double lat, double lon);

    bool is_missing() const;

    void set_lat(double lat);

    void set_lon(double lon);

    void set_lat(int lat);

    void set_lon(int lon);

    void set(int lat, int lon);

    void set(double lat, double lon);

    double dlat() const;

    double dlon() const;

    int compare(const Coords& o) const;
 
    bool operator==(const Coords& o) const;
    bool operator!=(const Coords& o) const;
    bool operator<(const Coords& o) const;
    bool operator>(const Coords& o) const;
    bool operator<=(const Coords& o) const;
    bool operator>=(const Coords& o) const;

    int print(FILE* out, const char* end = "\n") const;

    std::string to_string(const char* undef = "-") const;

    static int lat_to_int(double lat);

    static int lon_to_int(double lat);

    static double lat_from_int(int lat);

    static double lon_from_int(int lon);
};
 
std::ostream& operator<<(std::ostream&, const Coords&);

struct LatRange
{
    static constexpr int IMIN    = -9000000;
    static constexpr int IMAX    = 9000000;
    static constexpr double DMIN = -90.0;
    static constexpr double DMAX = 90.0;

    int imin = IMIN;
    int imax = IMAX;

    LatRange() = default;
    LatRange(int min, int max);
    LatRange(double min, double max);
 
    bool operator==(const LatRange& lr) const;
    bool operator!=(const LatRange& lr) const;

    bool is_missing() const;

    double dmin() const;

    double dmax() const;

    void get(double& min, double& max) const;

    void set(int min, int max);

    void set(double min, double max);

    bool contains(int lat) const;

    bool contains(double lat) const;

    bool contains(const LatRange& lr) const;

    int print(FILE* out, const char* end = "\n") const;
};
 
std::ostream& operator<<(std::ostream& out, const LatRange& lr);

struct LonRange
{
    int imin = MISSING_INT;
    int imax = MISSING_INT;

    LonRange() = default;
    LonRange(int min, int max);
    LonRange(double min, double max);
 
    bool operator==(const LonRange& lr) const;
    bool operator!=(const LonRange& lr) const;

    bool is_missing() const;

    double dmin() const;

    double dmax() const;

    void get(double& min, double& max) const;

    void set(int min, int max);

    void set(double min, double max);

    void set(const LonRange& lr);

    bool contains(int lon) const;

    bool contains(double lon) const;

    bool contains(const LonRange& lr) const;

    int print(FILE* out, const char* end = "\n") const;
};
 
std::ostream& operator<<(std::ostream& out, const LonRange& lr);

struct Level
{
    int ltype1;
    int l1;
    int ltype2;
    int l2;
 
    Level(int ltype1 = MISSING_INT, int l1 = MISSING_INT,
          int ltype2 = MISSING_INT, int l2 = MISSING_INT)
        : ltype1(ltype1), l1(l1), ltype2(ltype2), l2(l2)
    {
    }

    bool is_missing() const;
 
    bool operator==(const Level& o) const;
    bool operator!=(const Level& o) const;
    bool operator<(const Level& o) const;
    bool operator>(const Level& o) const;
    bool operator<=(const Level& o) const;
    bool operator>=(const Level& o) const;

    int compare(const Level& l) const;

    std::string describe() const;

    void to_stream(std::ostream& out, const char* undef = "-") const;

    std::string to_string(const char* undef = "-") const;

    void to_csv(CSVWriter& out) const;

    static Level cloud(int ltype2 = MISSING_INT, int l2 = MISSING_INT);

    int print(FILE* out, const char* undef = "-", const char* end = "\n") const;
};
 
std::ostream& operator<<(std::ostream& out, const Level& l);

struct Trange
{
    int pind;
    int p1;
    int p2;
 
    Trange(int pind = MISSING_INT, int p1 = MISSING_INT, int p2 = MISSING_INT)
        : pind(pind), p1(p1), p2(p2)
    {
    }

    bool is_missing() const;

    int compare(const Trange& t) const;
 
    bool operator==(const Trange& o) const;
    bool operator!=(const Trange& o) const;
    bool operator<(const Trange& o) const;
    bool operator>(const Trange& o) const;
    bool operator<=(const Trange& o) const;
    bool operator>=(const Trange& o) const;

    std::string describe() const;

    void to_stream(std::ostream& out, const char* undef = "-") const;

    std::string to_string(const char* undef = "-") const;

    void to_csv(CSVWriter& out) const;

    static Trange instant();

    int print(FILE* out, const char* undef = "-", const char* end = "\n") const;
};
 
std::ostream& operator<<(std::ostream& out, const Trange& l);

class Ident
{
protected:
    char* value = nullptr;
 
public:
    Ident() = default;
    Ident(const char* value);
    Ident(const std::string& value);
    Ident(const Ident& o);
    Ident(Ident&& o);
    ~Ident();
    Ident& operator=(const Ident& o);
    Ident& operator=(Ident&& o);
    Ident& operator=(const char* o);
    Ident& operator=(const std::string& o);

    const char* get() const { return value; }

    void clear();
 
    int compare(const Ident& o) const;
    int compare(const char* o) const;
    int compare(const std::string& o) const;
    template <typename T> bool operator==(const T& o) const
    {
        return compare(o) == 0;
    }
    template <typename T> bool operator!=(const T& o) const
    {
        return compare(o) != 0;
    }
    template <typename T> bool operator<(const T& o) const
    {
        return compare(o) < 0;
    }
    template <typename T> bool operator<=(const T& o) const
    {
        return compare(o) <= 0;
    }
    template <typename T> bool operator>(const T& o) const
    {
        return compare(o) > 0;
    }
    template <typename T> bool operator>=(const T& o) const
    {
        return compare(o) >= 0;
    }

    bool is_missing() const;
 
    operator const char*() const { return value; }
    operator std::string() const;
};
 
std::ostream& operator<<(std::ostream&, const Ident&);

class Report
{
protected:
    std::string value;
 
public:
    Report() = default;
    // cppcheck-suppress noExplicitConstructor
    Report(const char* value);
    // cppcheck-suppress noExplicitConstructor
    Report(const std::string& value);
    Report(const Report& value);
    Report(Report&& value);
 
    Report& operator=(const char* value);
    Report& operator=(const std::string& value);
    Report& operator=(const Report& value);
    Report& operator=(Report&& value);
 
    ~Report();
 
    operator const char*() const { return value.c_str(); }
    operator std::string() const { return value; }
 
    bool operator<(const Report& o) const { return value < o.value; }
    template <typename T> bool operator<(const T& o) const
    {
        return *this < Report(o);
    }
    bool operator<=(const Report& o) const { return value <= o.value; }
    template <typename T> bool operator<=(const T& o) const
    {
        return *this <= Report(o);
    }
    bool operator>(const Report& o) const { return value > o.value; }
    template <typename T> bool operator>(const T& o) const
    {
        return *this > Report(o);
    }
    bool operator>=(const Report& o) const { return value >= o.value; }
    template <typename T> bool operator>=(const T& o) const
    {
        return *this >= Report(o);
    }
    bool operator==(const Report& o) const { return value == o.value; }
    template <typename T> bool operator==(const T& o) const
    {
        return *this == Report(o);
    }
    bool operator!=(const Report& o) const { return value != o.value; }
    template <typename T> bool operator!=(const T& o) const
    {
        return *this != Report(o);
    }
 
    bool empty() const { return value.empty(); }
    void clear() { return value.clear(); }
    const char* c_str() const { return value.c_str(); }
};

struct Station
{
    Report report;

    Coords coords;

    Ident ident;
 
    Station() = default;

    bool is_missing() const;
 
    bool operator==(const Station& o) const
    {
        return std::tie(report, coords, ident) ==
               std::tie(o.report, o.coords, o.ident);
    }
    bool operator!=(const Station& o) const
    {
        return std::tie(report, coords, ident) !=
               std::tie(o.report, o.coords, o.ident);
    }
    bool operator<(const Station& o) const
    {
        return std::tie(report, coords, ident) <
               std::tie(o.report, o.coords, o.ident);
    }
    bool operator<=(const Station& o) const
    {
        return std::tie(report, coords, ident) <=
               std::tie(o.report, o.coords, o.ident);
    }
    bool operator>(const Station& o) const
    {
        return std::tie(report, coords, ident) >
               std::tie(o.report, o.coords, o.ident);
    }
    bool operator>=(const Station& o) const
    {
        return std::tie(report, coords, ident) >=
               std::tie(o.report, o.coords, o.ident);
    }

    int print(FILE* out, const char* end = "\n") const;

    std::string to_string(const char* undef = "-") const;
};
 
std::ostream& operator<<(std::ostream&, const Station&);
 
struct DBStation : public Station
{
    int id = MISSING_INT;
 
    DBStation() = default;

    bool is_missing() const;
 
    bool operator==(const DBStation& o) const
    {
        return std::tie(id, report, coords, ident) ==
               std::tie(o.id, o.report, o.coords, o.ident);
    }
    bool operator!=(const DBStation& o) const
    {
        return std::tie(id, report, coords, ident) !=
               std::tie(o.id, o.report, o.coords, o.ident);
    }
    bool operator<(const DBStation& o) const
    {
        return std::tie(id, report, coords, ident) <
               std::tie(o.id, o.report, o.coords, o.ident);
    }
    bool operator<=(const DBStation& o) const
    {
        return std::tie(id, report, coords, ident) <=
               std::tie(o.id, o.report, o.coords, o.ident);
    }
    bool operator>(const DBStation& o) const
    {
        return std::tie(id, report, coords, ident) >
               std::tie(o.id, o.report, o.coords, o.ident);
    }
    bool operator>=(const DBStation& o) const
    {
        return std::tie(id, report, coords, ident) >=
               std::tie(o.id, o.report, o.coords, o.ident);
    }

    int print(FILE* out, const char* end = "\n") const;

    std::string to_string(const char* undef = "-") const;
};
 
std::ostream& operator<<(std::ostream&, const DBStation&);
 
} // namespace dballe
 
namespace std {
 
template <> struct hash<dballe::Level>
{
    typedef dballe::Level argument_type;
    typedef size_t result_type;
    result_type operator()(argument_type const& o) const noexcept;
};
 
template <> struct hash<dballe::Trange>
{
    typedef dballe::Trange argument_type;
    typedef size_t result_type;
    result_type operator()(argument_type const& o) const noexcept;
};
 
template <> struct hash<dballe::Coords>
{
    typedef dballe::Coords argument_type;
    typedef size_t result_type;
    result_type operator()(argument_type const& o) const noexcept;
};
 
template <> struct hash<dballe::Ident>
{
    typedef dballe::Ident argument_type;
    typedef size_t result_type;
    result_type operator()(argument_type const& o) const noexcept;
};
 
template <> struct hash<dballe::Station>
{
    typedef dballe::Station argument_type;
    typedef size_t result_type;
    result_type operator()(argument_type const& o) const noexcept;
};
 
template <> struct hash<dballe::DBStation>
{
    typedef dballe::DBStation argument_type;
    typedef size_t result_type;
    result_type operator()(argument_type const& o) const noexcept;
};
 
} // namespace std
 
#endif