metkitlib 1.16.0.9__cp312-cp312-manylinux_2_28_aarch64.whl

metkitlib/include/metkit/mars/StepRange.h

@@ -0,0 +1,164 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+// File StepRange.h
+// Baudouin Raoult - ECMWF Dec 97
+
+#ifndef metkit_StepRange_H
+#define metkit_StepRange_H
+
+#include <cmath>
+
+#include "eckit/persist/Bless.h"
+#include "eckit/types/Time.h"
+#include "eckit/types/Types.h"
+
+namespace eckit {
+class DumpLoad;
+}
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class StepRange {
+public:
+
+    // -- Exceptions
+    // None
+
+    // -- Contructors
+
+    StepRange(const std::string&);
+
+    explicit StepRange(eckit::Time from = eckit::Time(0), eckit::Time to = eckit::Time(0)) :
+        from_(from / 3600.), to_(to / 3600.) {
+
+        if (from != eckit::Time(0) && to == eckit::Time(0)) {
+            to_ = from_;
+        }
+    }
+
+    explicit StepRange(double from, double to = 0) :
+        StepRange(eckit::Time(std::lround(from * 3600.), true), eckit::Time(std::lround(to * 3600.), true)) {}
+
+
+#include "metkit/mars/StepRange.b"
+
+    // -- Destructor
+
+    ~StepRange() {}
+
+    // -- Convertors
+    // None
+
+    // -- Operators
+    // None
+
+    operator std::string() const;
+    std::string toString(bool useDays = false, bool alwaysUseHours = false) const;
+
+    StepRange& operator+=(const eckit::Time& step) {
+        from_ += step / 3600.;
+        to_ += step / 3600.;
+        return *this;
+    }
+
+    StepRange& operator-=(const eckit::Time& step) {
+        from_ -= step / 3600.;
+        to_ -= step / 3600.;
+        return *this;
+    }
+
+    bool operator==(const StepRange& other) const { return from_ == other.from_ && to_ == other.to_; }
+
+    bool operator!=(const StepRange& other) const { return from_ != other.from_ || to_ != other.to_; }
+
+    bool operator<(const StepRange& other) const {
+        return (from_ != other.from_) ? (from_ < other.from_) : (to_ < other.to_);
+    }
+
+    bool operator<=(const StepRange& other) const {
+        return (from_ != other.from_) ? (from_ <= other.from_) : (to_ <= other.to_);
+    }
+
+    bool operator>(const StepRange& other) const { return other < *this; }
+
+    // -- Methods
+
+    double from() const { return from_; }
+    double to() const { return to_; }
+
+    void dump(eckit::DumpLoad&) const;
+    void load(eckit::DumpLoad&);
+
+    // -- Overridden methods
+    // None
+
+    // -- Class members
+    // None
+
+    // -- Class methods
+    // None
+
+    // Uncomment for persistent, remove otherwise
+
+protected:
+
+    // -- Members
+    // None
+
+    // -- Methods
+
+    void print(std::ostream& s, bool useDays = false, bool alwaysUseHours = false) const;
+
+    // -- Overridden methods
+    // None
+
+    // -- Class members
+    // None
+
+    // -- Class methods
+    // None
+
+private:
+
+    // No copy allowed
+
+    // -- Members
+
+    double from_;
+    double to_;
+
+    // -- Methods
+    // None
+
+    // -- Overridden methods
+    // None
+
+    // -- Class members
+    // None
+
+    // -- Class methods
+    // None
+
+    // -- Friends
+
+    friend std::ostream& operator<<(std::ostream& s, const StepRange& p) {
+        p.print(s);
+        return s;
+    }
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars
+
+#endif

metkitlib/include/metkit/mars/StepRangeNormalise.h

@@ -0,0 +1,95 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @author Simon Smart
+/// @date May 2019
+
+#ifndef metkit_StepRangeNormalise_H
+#define metkit_StepRangeNormalise_H
+
+#include <algorithm>
+
+#include "eckit/exception/Exceptions.h"
+#include "metkit/mars/StepRange.h"
+
+namespace metkit {
+namespace mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+// It would be nice to put this in StepRange (as is done with ParamID), but this seems
+// to break the generation of the StepRange.b file.
+//
+// -> Split it out
+
+class StepRangeNormalise {
+public:
+
+    template <typename AXIS_T>
+    static void normalise(std::vector<StepRange>& v, const AXIS_T& axis);
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+template <typename AXIS_T>
+void StepRangeNormalise::normalise(std::vector<StepRange>& values, const AXIS_T& axis) {
+
+    std::vector<StepRange> outputValues;
+
+    for (eckit::Ordinal i = 0; i < values.size(); ++i) {
+
+        // If the supplied range is found in the axis, then use that
+
+        auto j = std::find(axis.begin(), axis.end(), values[i]);
+        if (j != axis.end()) {
+            outputValues.push_back(values[i]);
+
+            // If specified, and matched, a RANGE, then use that
+            if (values[i].from() != values[i].to()) {
+                eckit::Log::info() << "Matched range: " << values[i] << std::endl;
+                continue;
+            }
+        }
+
+        bool matched       = false;
+        double singleValue = values[i].from();
+
+        if (values[i].from() != values[i].to()) {
+            j = std::find(axis.begin(), axis.end(), StepRange(singleValue, singleValue));
+            if (j != axis.end()) {
+                outputValues.push_back(*j);
+                matched = true;
+            }
+        }
+
+        // If singleValue == 0, this test is the same as the previous one...
+
+        if (singleValue != 0) {
+            j = std::find(axis.begin(), axis.end(), StepRange(0, singleValue));
+            if (j != axis.end()) {
+
+                if (matched) {
+                    eckit::Log::userWarning()
+                        << "Step " << values[i] << " matches " << values[i] << " and " << (*j) << std::endl;
+                }
+
+                outputValues.push_back(*j);
+            }
+        }
+    }
+
+    std::swap(values, outputValues);
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+}  // namespace mars
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/Type.h

@@ -0,0 +1,265 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @file   Type.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @author Emanuele Danovaro
+/// @date   April 2016
+
+#pragma once
+
+#include <functional>
+#include <iosfwd>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "eckit/memory/Counted.h"
+#include "eckit/value/Value.h"
+
+#include "metkit/mars/MarsRequest.h"
+
+namespace metkit::mars {
+
+class MarsExpandContext;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/// @brief abstract class - ContextRule subclasses are used to define a context. A MarsRequest matches a context, if it
+/// matches all its ContextRules
+class ContextRule {
+public:
+
+    ContextRule(const std::string& k) : key_(k) {}
+
+    virtual ~ContextRule() = default;
+
+    const std::string& key() const { return key_; }
+
+    virtual bool matches(MarsRequest req) const = 0;
+
+    friend std::ostream& operator<<(std::ostream& s, const ContextRule& r) {
+        r.print(s);
+        return s;
+    }
+
+protected:
+
+    std::string key_;
+
+private:  // methods
+
+    virtual void print(std::ostream& out) const = 0;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/// @brief A MarsRequest matches an Include ContextRule if at least one of the mars request values matches with the
+/// values associated with the Include rule
+class Include : public ContextRule {
+public:
+
+    Include(const std::string& k, const std::set<std::string>& vv) : ContextRule(k), vals_(vv) {}
+
+    bool matches(MarsRequest req) const override {
+        if (key_ == "_verb") {
+            return (vals_.find(req.verb()) != vals_.end());
+        }
+        if (!req.has(key_)) {
+            return false;
+        }
+        for (const std::string& v : req.values(key_)) {
+            if (vals_.find(v) != vals_.end()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+private:  // methods
+
+    void print(std::ostream& out) const override { out << "Include[key=" << key_ << ",vals=[" << vals_ << "]]"; }
+
+private:
+
+    std::set<std::string> vals_;
+};
+
+/// @brief A MarsRequest matches an Exclude ContextRule if none of the mars request values matches with the values
+/// associated with the Exclude rule
+class Exclude : public ContextRule {
+public:
+
+    Exclude(const std::string& k, const std::set<std::string>& vv) : ContextRule(k), vals_(vv) {}
+    bool matches(MarsRequest req) const override {
+        if (!req.has(key_)) {
+            return false;
+        }
+        for (const std::string& v : req.values(key_)) {
+            if (vals_.find(v) != vals_.end()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+private:  // methods
+
+    void print(std::ostream& out) const override { out << "Exclude[key=" << key_ << ",vals=[" << vals_ << "]]"; }
+
+private:
+
+    std::set<std::string> vals_;
+};
+
+/// @brief A MarsRequest matches an Undef ContextRule if the specified keyword is not defined in the mars request
+class Undef : public ContextRule {
+public:
+
+    Undef(const std::string& k) : ContextRule(k) {}
+    bool matches(MarsRequest req) const override { return !req.has(key_); }
+
+private:  // methods
+
+    void print(std::ostream& out) const override { out << "Undef[key=" << key_ << "]"; }
+};
+
+/// @brief A MarsRequest matches an Undef ContextRule if the specified keyword is defined in the mars request
+class Def : public ContextRule {
+public:
+
+    Def(const std::string& k) : ContextRule(k) {}
+    bool matches(MarsRequest req) const override { return req.has(key_); }
+
+private:  // methods
+
+    void print(std::ostream& out) const override { out << "Def[key=" << key_ << "]"; }
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/// @brief a Context contains a list of ContextRule. A MarsRequest matches a context, if it matches all the ContextRules
+/// associated
+class Context {
+public:
+
+    static std::unique_ptr<Context> parseContext(eckit::Value c);
+
+    /// @note takes ownership of the rule
+    void add(std::unique_ptr<ContextRule> rule);
+
+    size_t maxAxisIndex() const;
+
+    bool matches(MarsRequest req) const;
+
+    friend std::ostream& operator<<(std::ostream& s, const Context& x);
+
+private:  // methods
+
+    void print(std::ostream& out) const;
+
+private:
+
+    std::vector<std::unique_ptr<ContextRule>> rules_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class ITypeToByList {
+public:
+
+    virtual ~ITypeToByList()                                                                      = default;
+    virtual void expandRanges(std::vector<std::string>& values, const MarsRequest& request) const = 0;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class Type : public eckit::Counted {
+public:  // methods
+
+    Type(const std::string& name, const eckit::Value& settings);
+
+    ~Type() noexcept override = default;
+
+    virtual bool expand(std::string& value, const MarsRequest& request = {}) const;
+    [[deprecated]] bool expand(const MarsExpandContext& ctx, std::string& value, const MarsRequest& request = {}) const;
+    void expand(std::vector<std::string>& values, const MarsRequest& request = {}) const;
+
+    std::string tidy(const std::string& value, const MarsRequest& request = {}) const;
+
+    virtual void setDefaults(MarsRequest& request);
+    virtual void setInheritance(const std::vector<std::string>& inheritance);
+    virtual void check(const std::vector<std::string>& values) const;
+    virtual void clearDefaults();
+    virtual void reset();
+
+    virtual void pass2(MarsRequest& request);
+    virtual void finalise(MarsRequest& request, bool strict);
+
+    virtual const std::vector<std::string>& flattenValues(const MarsRequest& request);
+    virtual bool flatten() const;
+    virtual bool multiple() const;
+
+    virtual bool filter(const std::vector<std::string>& filter, std::vector<std::string>& values) const;
+    virtual bool filter(const std::string& keyword, const std::vector<std::string>& filter,
+                        std::vector<std::string>& values) const;
+    virtual bool matches(const std::vector<std::string>& filter, const std::vector<std::string>& values) const;
+
+    const std::string& name() const;
+    const std::string& category() const;
+
+    friend std::ostream& operator<<(std::ostream& s, const Type& x);
+
+    virtual size_t count(const std::vector<std::string>& values) const;
+
+protected:  // methods
+
+    virtual bool hasGroups() const { return false; }
+    virtual std::optional<std::reference_wrapper<const std::vector<std::string>>> group(const std::string&) const {
+        NOTIMP;
+    }
+
+    friend class MarsLanguage;
+
+    void defaults(std::shared_ptr<Context> context, const std::vector<std::string>& values);
+    void set(std::shared_ptr<Context> context, const std::vector<std::string>& values);
+    void unset(std::shared_ptr<Context> context);
+
+protected:  // members
+
+    std::string name_;
+    std::string category_;
+
+    bool flatten_;
+    bool multiple_;
+    bool duplicates_;
+
+    std::map<std::shared_ptr<Context>, std::vector<std::string>> defaults_;
+    std::map<std::shared_ptr<Context>, std::vector<std::string>> sets_;
+    std::set<std::shared_ptr<Context>> unsets_;
+
+    std::optional<std::vector<std::string>> inheritance_;
+
+    std::unique_ptr<ITypeToByList> toByList_;
+
+    std::map<std::string, std::function<bool(const std::vector<std::string>&, std::vector<std::string>&)>> filters_;
+
+private:  // methods
+
+    virtual void print(std::ostream& out) const = 0;
+    void patchRequest(MarsRequest& request, const std::vector<std::string>& values);
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypeAny.h

@@ -0,0 +1,39 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @file   TypeAny.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   April 2016
+
+#pragma once
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeAny : public Type {
+
+public:  // methods
+
+    TypeAny(const std::string& name, const eckit::Value& settings = eckit::Value());
+
+    ~TypeAny() noexcept override = default;
+
+private:  // methods
+
+    void print(std::ostream& out) const override;
+    bool expand(std::string& value, const MarsRequest& request) const override;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypeDate.h

@@ -0,0 +1,42 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @file   TypeDate.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @author Emanuele Danovaro
+/// @date   April 2016
+
+#pragma once
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeDate : public Type {
+
+public:  // methods
+
+    TypeDate(const std::string& name, const eckit::Value& settings);
+
+    ~TypeDate() noexcept override = default;
+
+private:  // methods
+
+    void print(std::ostream& out) const override;
+    void pass2(MarsRequest& request) override;
+    bool expand(std::string& value, const MarsRequest& request) const override;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypeEnum.h

@@ -0,0 +1,67 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @file   TypeEnum.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   April 2016
+
+#pragma once
+
+#include <mutex>
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeEnum : public Type {
+
+public:  // methods
+
+    TypeEnum(const std::string& name, const eckit::Value& settings);
+
+    ~TypeEnum() noexcept override = default;
+
+private:  // methods
+
+    bool hasGroups() const override { return hasGroups_; }
+    std::optional<std::reference_wrapper<const std::vector<std::string>>> group(
+        const std::string& value) const override;
+
+    void print(std::ostream& out) const override;
+    void reset() override;
+
+    bool expand(std::string& value, const MarsRequest& request) const override;
+    std::map<std::string, uint16_t>::const_iterator find(const std::string& value) const;
+
+    std::vector<std::string> parseEnumValue(const eckit::Value& val, bool allowDuplicates = false) const;
+
+    void addValue(const std::string& value, uint16_t idx, bool allowDuplicates) const;
+    uint16_t parseValueNames(const eckit::Value& names, bool allowDuplicates) const;
+
+    void readValuesFile() const;
+
+private:  // members
+
+    std::string valuesFile_;
+
+    bool uppercase_         = false;
+    mutable bool hasGroups_ = false;
+    mutable std::vector<std::pair<std::string, std::vector<std::string>>> groups_;
+    mutable std::map<std::string, uint16_t> values_;  // map of acceptable values (included aliases)
+
+    mutable std::once_flag readValues_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars