epel-8-x86_64/10928365-dballe/libdballe-doc-9.14-1.el8.x86_64.rpm

 #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
dballe::LatRange::dmax
double dmax() const
Get the upper extreme as double.

dballe::CSVWriter
Definition: csv.h:139

dballe::Datetime::time
Time time() const
Return a Time with this time.

dballe::Level::ltype1
int ltype1
Type of the level or the first layer.
Definition: types.h:627

dballe::LatRange::IMIN
static constexpr int IMIN
Minimum possible integer value.
Definition: types.h:472

dballe::Time::to_stream_iso8601
void to_stream_iso8601(std::ostream &out) const
Write the time to an output stream in ISO8601 extended format (hh:mm:ss).

dballe::LonRange::LonRange
LonRange()=default
Construct a range that matches any longitude.

dballe::Level::ltype2
int ltype2
Type of the the second layer.
Definition: types.h:631

dballe::Time::to_csv_iso8601
void to_csv_iso8601(CSVWriter &out) const
Write the time as a CSV field in ISO8601 date format.

dballe::Station::ident
Ident ident
Mobile station identifier.
Definition: types.h:887

dballe::Coords::Coords
Coords()=default
Construct a missing Coords.

dballe::Trange::describe
std::string describe() const
Return a string description of this time range.

dballe::Coords::dlat
double dlat() const
Get the latitude in degrees.

dballe::Datetime::Datetime
Datetime()
Construct a missing datetime.

dballe::LatRange::contains
bool contains(int lat) const
Check if a point is inside this range (extremes included)

dballe::Station
Station information.
Definition: types.h:878

dballe::Ident::is_missing
bool is_missing() const
Check if the Ident is set to the missing value.

dballe::Datetime::date
Date date() const
Return a Date with this date.

dballe::Date::validate
static void validate(int ye, int mo, int da)
Raise an exception if the three values do not represent a valid date.

dballe::Time::Time
Time()
Construct a missing time.

dballe::Time::compare
int compare(const Time &other) const
Generic comparison.

dballe::Trange::instant
static Trange instant()
Time range for instant values.

dballe::LatRange::is_missing
bool is_missing() const
Return true if the LatRange matches any latitude.

dballe::Level::print
int print(FILE *out, const char *undef="-", const char *end="\) const
Print to an output stream.

dballe::Date::julian_to_calendar
static void julian_to_calendar(int jday, unsigned short &year, unsigned char &month, unsigned char &day)
Convert a Julian day into a calendar date.

dballe::Trange::compare
int compare(const Trange &t) const
Generic comparison.

dballe::Station::report
Report report
Report name for this station.
Definition: types.h:881

dballe::Date
Calendar date.
Definition: types.h:27

dballe::DatetimeRange::is_missing
bool is_missing() const
Check if this range is open on both sides.

dballe::DBStation::is_missing
bool is_missing() const
Return true if all the station fields are empty.

dballe::Station::coords
Coords coords
Station coordinates.
Definition: types.h:884

dballe::Datetime::upper_bound
static Datetime upper_bound(int ye, int mo, int da, int ho, int mi, int se)
Return a Datetime filling the parts set to MISSING_INT with their highest possible values...

dballe::Coords
Coordinates.
Definition: types.h:371

dballe::LatRange::IMAX
static constexpr int IMAX
Maximum possible integer value.
Definition: types.h:474

dballe::Level::to_string
std::string to_string(const char *undef="-") const
Format to a string.

dballe::Trange::p1
int p1
Time range P1 indicator.
Definition: types.h:693

dballe::Trange::to_csv
void to_csv(CSVWriter &out) const
Write the datetime to a CSV writer as 3 fields.

dballe::Datetime::print_iso8601
int print_iso8601(FILE *out, char sep='T', const char *end="\) const
Print to an output stream in ISO8601 combined format.

dballe::Trange::to_string
std::string to_string(const char *undef="-") const
Format to a string.

dballe::Date::calendar_to_julian
static int calendar_to_julian(int year, int month, int day)
Convert a calendar date into a Julian day.

std
Definition: utils.h:40

dballe::LonRange::imin
int imin
Initial point of the longitude range.
Definition: types.h:555

dballe::DBStation::to_string
std::string to_string(const char *undef="-") const
Format to a string.

dballe::Coords::set_lat
void set_lat(double lat)
Set the latitude only.

dballe::Trange
Information on how a value has been sampled or computed with regards to time.
Definition: types.h:688

dballe::Coords::print
int print(FILE *out, const char *end="\) const
Print to an output stream.

dballe::LatRange::DMAX
static constexpr double DMAX
Maximum possible double value.
Definition: types.h:478

dballe::Datetime::normalise_h24
static void normalise_h24(int &ye, int &mo, int &da, int &ho, int &mi, int &se)
Convert a datetime with an hour of 24:00:00 to hour 00:00:00 of the following day.

dballe::Level::to_stream
void to_stream(std::ostream &out, const char *undef="-") const
Format to an output stream.

dballe::Trange::pind
int pind
Time range type indicator.
Definition: types.h:691

dballe::Coords::lon_to_int
static int lon_to_int(double lat)
Convert a longitude to the internal integer representation.

dballe::Datetime::set_lower_bound
void set_lower_bound()
Fill possibly missing fields with their lowest valid value.

dballe::LonRange::dmax
double dmax() const
Get the upper extreme as double, or 180.0 if missing.

dballe::Date::to_stream_iso8601
void to_stream_iso8601(std::ostream &out) const
Write the date to an output stream in ISO8601 date format.

dballe::Station::print
int print(FILE *out, const char *end="\) const
Print the Station to a FILE*.

dballe::Coords::lat_to_int
static int lat_to_int(double lat)
Convert a latitude to the internal integer representation.

dballe
Definition: cmdline.h:18

dballe::Datetime::from_julian
static Datetime from_julian(int jday, int ho=0, int mi=0, int se=0)
Set the date from a Julian day.

dballe::Date::to_julian
int to_julian() const
Convert the date to Julian day.

dballe::DatetimeRange::print
int print(FILE *out, const char *end="\) const
Print to an output stream in ISO8601 combined format.

dballe::Date::from_julian
static Date from_julian(int jday)
Create a date from a Julian day.

dballe::LatRange::DMIN
static constexpr double DMIN
Minimum possible double value.
Definition: types.h:476

dballe::Station::is_missing
bool is_missing() const
Return true if all the station fields are empty.

dballe::LonRange::contains
bool contains(int lon) const
Check if a point is inside this range (extremes included)

dballe::Datetime::to_stream_iso8601
void to_stream_iso8601(std::ostream &out, char sep='T', const char *tz="") const
Write the datetime to an output stream in ISO8601 combined format.

dballe::DBStation::print
int print(FILE *out, const char *end="\) const
Print the Station to a FILE*.

dballe::Level
Vertical level or layer.
Definition: types.h:624

dballe::LonRange::print
int print(FILE *out, const char *end="\) const
Print the LonRange to a FILE*.

dballe::LonRange::is_missing
bool is_missing() const
Return true if the LonRange matches any longitude.

dballe::Ident
A station identifier, that can be any string (including the empty string) or a missing value...
Definition: types.h:750

dballe::Datetime::lower_bound
static Datetime lower_bound(int ye, int mo, int da, int ho, int mi, int se)
Return a Datetime filling the parts set to MISSING_INT with their lowest possible values...

dballe::Coords::lon_from_int
static double lon_from_int(int lon)
Convert a longitude from the internal integer representation.

dballe::Datetime::to_string
std::string to_string(char sep='T', const char *tz="") const
Write to a string in ISO8601 combined format.

dballe::Level::l2
int l2
L2 value of the second layer.
Definition: types.h:633

dballe::Datetime::to_julian
int to_julian() const
Convert the date to Julian day.

dballe::Date::is_missing
bool is_missing() const
Check if this date is the missing value.

dballe::DatetimeRange::contains
bool contains(const Datetime &dt) const
Check if a Datetime is inside this range.

dballe::Datetime::set_upper_bound
void set_upper_bound()
Fill possibly missing fields with their highest valid value.

dballe::DatetimeRange
Range of datetimes.
Definition: types.h:296

dballe::Station::to_string
std::string to_string(const char *undef="-") const
Format to a string.

dballe::LonRange::imax
int imax
Final point of the longitude range.
Definition: types.h:557

dballe::Date::to_csv_iso8601
void to_csv_iso8601(CSVWriter &out) const
Write the date as a CSV field in ISO8601 date format.

dballe::DatetimeRange::max
Datetime max
Upper bound of the range.
Definition: types.h:301

dballe::Time::is_missing
bool is_missing() const
Check if this time is the missing value.

dballe::Ident::clear
void clear()
Set to missing value.

dballe::Trange::to_stream
void to_stream(std::ostream &out, const char *undef="-") const
Format to an output stream.

dballe::Coords::lat
int lat
Latitude in 1/100000 of a degree (5 significant digits preserved)
Definition: types.h:374

dballe::LatRange::imin
int imin
Minimum latitude.
Definition: types.h:481

dballe::DBStation::id
int id
Database ID of the station.
Definition: types.h:946

dballe::LatRange
Range of latitudes.
Definition: types.h:469

dballe::Datetime::validate
static void validate(int ye, int mo, int da, int ho, int mi, int se)
Raise an exception if the three values do not represent a valid date/time.

dballe::Time
Time of the day.
Definition: types.h:99

dballe::LatRange::LatRange
LatRange()=default
Construct a LatRange matching any latitude.

dballe::DatetimeRange::min
Datetime min
Lower bound of the range.
Definition: types.h:299

dballe::Coords::lon
int lon
Longitude in 1/100000 of a degree (5 significant digits preserved) and normalised between -180...
Definition: types.h:380

dballe::Coords::compare
int compare(const Coords &o) const
Compare two Coords strutures, for use in sorting.

dballe::LatRange::dmin
double dmin() const
Get the lower extreme as double.

dballe::Datetime::print
int print(FILE *out, const char *end="\) const
Print to an output stream in ISO8601 combined format.

dballe::Datetime::to_csv_iso8601
void to_csv_iso8601(CSVWriter &out, char sep='T', const char *tz="") const
Write the datetime as a CSV field in ISO8601 date format.

wreport

varinfo.h

dballe::Datetime
Date and time.
Definition: types.h:163

dballe::LatRange::imax
int imax
Maximum latitude.
Definition: types.h:483

dballe::Level::compare
int compare(const Level &l) const
Generic comparison.

dballe::Report
A report name.
Definition: types.h:815

dballe::DatetimeRange::is_disjoint
bool is_disjoint(const DatetimeRange &dtr) const
Check if the two ranges are completely disjoint.

dballe::Datetime::from_iso8601
static Datetime from_iso8601(const char *str)
Parse an ISO8601 datetime string.

dballe::Date::compare
int compare(const Date &other) const
Generic comparison.

dballe::Coords::dlon
double dlon() const
Get the longitude in degrees.

dballe::Datetime::is_missing
bool is_missing() const
Check if this datetime is the missing value.

dballe::Date::Date
Date()
Construct a missing date.

dballe::Coords::is_missing
bool is_missing() const
Check if these coordinates are undefined.

dballe::DBStation
Definition: types.h:939

dballe::Level::describe
std::string describe() const
Return a string description of this level.

dballe::Coords::lat_from_int
static double lat_from_int(int lat)
Convert a latitude from the internal integer representation.

dballe::DatetimeRange::merge
void merge(const DatetimeRange &range)
Merge range into this one, resulting in the smallest range that contains both.

dballe::Date::days_in_month
static int days_in_month(int year, int month)
Return the number of days in the given month.

dballe::LonRange
Range of longitudes.
Definition: types.h:552

dballe::Trange::print
int print(FILE *out, const char *undef="-", const char *end="\) const
Print to an output stream.

dballe::Level::l1
int l1
L1 value of the level or the first layer.
Definition: types.h:629

dballe::Datetime::compare
int compare(const Datetime &other) const
Generic comparison.

dballe::Level::cloud
static Level cloud(int ltype2=MISSING_INT, int l2=MISSING_INT)
Create a cloud special level.

dballe::Trange::p2
int p2
Time range P2 indicator.
Definition: types.h:695

dballe::Coords::set_lon
void set_lon(double lon)
Set the longitude only.

dballe::Trange::is_missing
bool is_missing() const
Check if this level is fully set to the missing value.

dballe::Coords::to_string
std::string to_string(const char *undef="-") const
Format to a string.

dballe::LatRange::print
int print(FILE *out, const char *end="\) const
Print the LatRange to a FILE*.

dballe::Time::validate
static void validate(int ho, int mi, int se)
Raise an exception if the three values do not represent a valid time.

dballe::LonRange::dmin
double dmin() const
Get the lower extreme as double, or -180.0 if missing.

dballe::Level::to_csv
void to_csv(CSVWriter &out) const
Write the datetime to a CSV writer as 4 fields.

dballe::Level::is_missing
bool is_missing() const
Check if this level is fully set to the missing value.