core/query.h

#ifndef DBALLE_CORE_QUERY_H
#define DBALLE_CORE_QUERY_H

#include <dballe/core/defs.h>
#include <dballe/core/fwd.h>
#include <dballe/query.h>
#include <set>
#include <wreport/varinfo.h>

#define DBA_DB_MODIFIER_BEST (1 << 0)

#define DBA_DB_MODIFIER_UNSORTED (1 << 5)

#define DBA_DB_MODIFIER_SORT_FOR_EXPORT (1 << 7)
#define DBA_DB_MODIFIER_SUMMARY_DETAILS (1 << 8)
#define DBA_DB_MODIFIER_WITH_ATTRIBUTES (1 << 9)

#define DBA_DB_MODIFIER_LAST (1 << 10)

namespace dballe {
namespace core {

struct JSONWriter;

struct Query : public dballe::Query
{
    static const uint32_t WANT_MISSING_IDENT  = (1 << 0);
    static const uint32_t WANT_MISSING_LTYPE1 = (1 << 1);
    static const uint32_t WANT_MISSING_L1     = (1 << 2);
    static const uint32_t WANT_MISSING_LTYPE2 = (1 << 3);
    static const uint32_t WANT_MISSING_L2     = (1 << 4);
    static const uint32_t WANT_MISSING_PIND   = (1 << 5);
    static const uint32_t WANT_MISSING_P1     = (1 << 6);
    static const uint32_t WANT_MISSING_P2     = (1 << 7);

    uint32_t want_missing = 0;
    int ana_id            = MISSING_INT;
    int priomin           = MISSING_INT;
    int priomax           = MISSING_INT;
    Report report;
    int mobile = MISSING_INT;
    Ident ident;
    LatRange latrange;
    LonRange lonrange;
    DatetimeRange dtrange;
    Level level;
    Trange trange;
    std::set<wreport::Varcode> varcodes;
    std::string query;
    std::string ana_filter;
    std::string data_filter;
    std::string attr_filter;
    int limit   = MISSING_INT;
    int block   = MISSING_INT;
    int station = MISSING_INT;

    bool operator==(const Query& o) const
    {
        return std::tie(want_missing, ana_id, priomin, priomax, report, mobile,
                        ident, latrange, lonrange, dtrange, level, trange,
                        varcodes, query, ana_filter, data_filter, attr_filter,
                        limit, block, station) ==
               std::tie(o.want_missing, o.ana_id, o.priomin, o.priomax,
                        o.report, o.mobile, o.ident, o.latrange, o.lonrange,
                        o.dtrange, o.level, o.trange, o.varcodes, o.query,
                        o.ana_filter, o.data_filter, o.attr_filter, o.limit,
                        o.block, o.station);
    }

    void validate();

    std::unique_ptr<dballe::Query> clone() const override;

    unsigned get_modifiers() const;

    DatetimeRange get_datetimerange() const override { return dtrange; }
    void set_datetimerange(const DatetimeRange& dt) override { dtrange = dt; }
    LatRange get_latrange() const override { return latrange; }
    void set_latrange(const LatRange& lr) override { latrange = lr; }
    LonRange get_lonrange() const override { return lonrange; }
    void set_lonrange(const LonRange& lr) override { lonrange = lr; }
    Level get_level() const override { return level; }
    void set_level(const Level& level) override { this->level = level; }
    Trange get_trange() const override { return trange; }
    void set_trange(const Trange& trange) override { this->trange = trange; }

    void clear() override;
    bool empty() const override;

    void set_from_string(const char* str);

    void set_from_test_string(const std::string& s);

    bool is_subquery(const dballe::Query& other) const override;

    void print(FILE* out) const override;

    void serialize(JSONWriter& out) const;

    static unsigned parse_modifiers(const char* str);

    static const Query& downcast(const dballe::Query& query);

    static Query& downcast(dballe::Query& query);

    static Query from_json(core::json::Stream& in);

protected:
    void setf(const char* key, unsigned len, const char* val);
    void unset(const char* key, unsigned len);
};

} // namespace core
} // namespace dballe
#endif