metkitlib 1.16.0.9__cp312-cp312-manylinux_2_28_aarch64.whl

metkitlib/include/metkit/mars/TypeExpver.h

@@ -0,0 +1,40 @@
+/*
+ * (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   TypeExpver.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   April 2016
+
+#pragma once
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeExpver : public Type {
+public:  // methods
+
+    TypeExpver(const std::string& name, const eckit::Value& settings);
+
+    ~TypeExpver() noexcept override = default;
+
+    bool expand(std::string& value, const MarsRequest& request) const override;
+
+private:  // methods
+
+    void print(std::ostream& out) const override;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypeFloat.h

@@ -0,0 +1,41 @@
+/*
+ * (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   TypeFloat.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @author Emanuele Danovaro
+/// @date   April 2016
+
+#pragma once
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeFloat : public Type {
+
+public:  // methods
+
+    TypeFloat(const std::string& name, const eckit::Value& settings);
+
+    ~TypeFloat() 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/TypeInteger.h

@@ -0,0 +1,55 @@
+/*
+ * (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   TypeInteger.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @author Emanuele Danovaro
+/// @date   April 2016
+
+#pragma once
+
+#include <iosfwd>
+#include <optional>
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeInteger : public Type {
+
+public:  // methods
+
+    TypeInteger(const std::string& name, const eckit::Value& settings);
+
+protected:
+
+    bool ok(const std::string& value, long& n) const;
+    bool expand(std::string& value, const MarsRequest& request) const override;
+
+private:  // methods
+
+    void print(std::ostream& out) const override;
+
+private:  // members
+
+    struct Range {
+        int lower_;
+        int upper_;
+    };
+
+    std::optional<Range> range_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypeLowercase.h

@@ -0,0 +1,38 @@
+/*
+ * (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   TypeLowercase.h
+/// @author Emanuele Danovaro
+/// @date   February 2024
+
+#pragma once
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeLowercase : public Type {
+
+public:  // methods
+
+    TypeLowercase(const std::string& name, const eckit::Value& settings = eckit::Value());
+
+    ~TypeLowercase() 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/TypeMixed.h

@@ -0,0 +1,47 @@
+/*
+ * (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   TypeMixed.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   April 2016
+
+#ifndef metkit_TypeMixed_H
+#define metkit_TypeMixed_H
+
+#include "metkit/mars/Type.h"
+
+namespace metkit {
+namespace mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeMixed : public Type {
+
+public:  // methods
+
+    TypeMixed(const std::string& name, const eckit::Value& settings);
+
+    ~TypeMixed() noexcept override;
+
+private:  // methods
+
+    void print(std::ostream& out) const override;
+    bool expand(std::string& value, const MarsRequest& request) const override;
+
+    std::vector<std::pair<std::unique_ptr<Context>, Type*>> types_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace mars
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/TypeParam.h

@@ -0,0 +1,45 @@
+/*
+ * (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   TypeParam.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   April 2016
+
+#pragma once
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeParam : public Type {
+
+public:  // methods
+
+    TypeParam(const std::string& name, const eckit::Value& settings);
+
+    ~TypeParam() noexcept override = default;
+
+private:  // methods
+
+    eckit::ValueMap expandWith_;
+    bool firstRule_;
+
+    void print(std::ostream& out) const override;
+    void reset() override;
+    void pass2(MarsRequest& request) override;
+    bool expand(std::string& value, const MarsRequest& request) const override;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypeRange.h

@@ -0,0 +1,41 @@
+/*
+ * (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   TypeRange.h
+/// @author Emanuele Danovaro
+/// @date   February 2022
+
+#pragma once
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+class StepRange;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeRange : public Type {
+
+public:  // methods
+
+    TypeRange(const std::string& name, const eckit::Value& settings);
+
+    ~TypeRange() 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/TypeRegex.h

@@ -0,0 +1,49 @@
+/*
+ * (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   TypeRegex.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   April 2016
+
+#ifndef metkit_TypeRegex_H
+#define metkit_TypeRegex_H
+
+#include "eckit/utils/Regex.h"
+#include "metkit/mars/Type.h"
+
+namespace metkit {
+namespace mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeRegex : public Type {
+
+public:  // methods
+
+    TypeRegex(const std::string& name, const eckit::Value& settings);
+
+    ~TypeRegex() noexcept override = default;
+
+private:  // methods
+
+    void print(std::ostream& out) const override;
+    bool expand(std::string& value, const MarsRequest& request) const override;
+
+    std::vector<eckit::Regex> regex_;
+    bool uppercase_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace mars
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/TypeTime.h

@@ -0,0 +1,44 @@
+/*
+ * (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   TypeTime.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @author Emanuele Danovaro
+/// @date   April 2016
+
+#ifndef metkit_TypeTime_H
+#define metkit_TypeTime_H
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeTime : public Type {
+
+public:  // methods
+
+    TypeTime(const std::string& name, const eckit::Value& settings);
+
+    ~TypeTime() 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
+
+#endif

metkitlib/include/metkit/mars/TypeToByList.h

@@ -0,0 +1,137 @@
+/*
+ * (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   TypeToByList.h
+/// @author Emanuele Danovaro
+/// @date   March 2025
+
+#pragma once
+
+#include "eckit/exception/Exceptions.h"
+#include "eckit/utils/StringTools.h"
+#include "eckit/utils/Translator.h"
+
+#include "metkit/mars/Type.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+template <typename EL, typename BY>
+class TypeToByList : public ITypeToByList {
+
+private:  // members
+
+    const Type& type_;
+    const std::string by_;
+
+public:  // methods
+
+    TypeToByList(const Type& type, const eckit::Value& settings) :
+        type_(type), by_(settings.contains("by") ? settings["by"] : "1") {}
+
+    virtual ~TypeToByList() = default;
+
+    void expandRanges(std::vector<std::string>& values, const MarsRequest& request) const override {
+
+        if (values.size() == 1) {
+            return;
+        }
+
+        static eckit::Translator<std::string, EL> s2el;
+        static eckit::Translator<std::string, BY> s2by;
+        static eckit::Translator<EL, std::string> el2s;
+
+        std::vector<std::string> newval;
+
+        for (size_t i = 0; i < values.size(); ++i) {
+
+            const std::string& s = values[i];
+
+            if (eckit::StringTools::lower(s) == "to" || eckit::StringTools::lower(s) == "t0") {
+                // TimeUnit unit;
+
+                if (newval.size() == 0) {
+                    std::ostringstream oss;
+                    oss << type_.name() << " list: 'to' must be preceeded by a starting value.";
+                    throw eckit::BadValue(oss.str());
+                }
+                if (values.size() <= i + 1) {
+                    std::ostringstream oss;
+                    oss << type_.name() << " list: 'to' must be followed by an ending value.";
+                    throw eckit::BadValue(oss.str());
+                }
+
+                EL from          = s2el(type_.tidy(values[i - 1], request));
+                std::string to_s = type_.tidy(values[i + 1], request);
+                EL to            = s2el(to_s);
+                BY by            = s2by(by_);
+
+                if (i + 2 < values.size() && eckit::StringTools::lower(values[i + 2]) == "by") {
+                    if (values.size() <= i + 3) {
+                        std::ostringstream oss;
+                        oss << type_.name() << " list: 'by' must be followed by a step size.";
+                        throw eckit::BadValue(oss.str());
+                    }
+
+                    by = s2by(values[i + 3]);
+                    i += 2;
+                }
+                i++;
+
+                if (by == BY{0}) {
+                    std::ostringstream oss;
+                    oss << type_.name() + ": 'by' value " << by << " cannot be zero";
+                    throw eckit::BadValue(oss.str());
+                }
+                if (from < to && by < BY{0}) {
+                    std::ostringstream oss;
+                    oss << type_.name() << ": impossible to define a sequence starting from " << from << " to " << to
+                        << " with step " << by;
+                    throw eckit::BadValue(oss.str());
+                }
+                bool addBy = (from < to && by > BY{0}) || (from > to && by < BY{0});
+                if (from == to) {
+                    continue;
+                }
+
+                EL j = from;
+                while (j != to) {
+                    std::string j_s;
+                    try {
+                        if (addBy) {
+                            j += by;
+                        }
+                        else {
+                            j -= by;
+                        }
+                        j_s = type_.tidy(el2s(j), request);
+                    }
+                    catch (...) {
+                        break;  /// reached an invalid value
+                    }
+
+                    if (((from < to && j > to) || (from > to && j < to)) && j != to && j_s != to_s) {
+                        break;
+                    }
+                    newval.push_back(j_s);
+                }
+            }
+            else {
+                newval.push_back(type_.tidy(s, request));
+            }
+        }
+
+        std::swap(values, newval);
+    }
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypeToByListQuantile.h

@@ -0,0 +1,41 @@
+/*
+ * (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   TypeToByListQuantile.h
+/// @author Emanuele Danovaro
+/// @date   February 2022
+
+#pragma once
+
+#include "metkit/mars/Quantile.h"
+#include "metkit/mars/Type.h"
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class TypeToByListQuantile : public Type {
+
+public:  // methods
+
+    TypeToByListQuantile(const std::string& name, const eckit::Value& settings);
+
+    ~TypeToByListQuantile() noexcept override = default;
+
+private:  // methods
+
+    void print(std::ostream& out) const override;
+    bool expand(std::string& value, const MarsRequest& request) const override;
+
+    std::set<long> denominators_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/TypesFactory.h

@@ -0,0 +1,92 @@
+/*
+ * (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   TypesFactory.h
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   April 2016
+
+#ifndef metkit_TypesFactory_H
+#define metkit_TypesFactory_H
+
+#include <string>
+
+#include "eckit/memory/NonCopyable.h"
+#include "eckit/types/Types.h"
+
+namespace eckit {
+class Value;
+}
+
+namespace metkit {
+namespace mars {
+
+class Type;
+class TypesFactory;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+
+class TypesRegistry : private eckit::NonCopyable {
+    eckit::Mutex mutex_;
+    std::map<std::string, TypesFactory*> m_;
+
+public:
+
+    static TypesRegistry& instance();
+
+    void add(const std::string& name, TypesFactory* f);
+    void remove(const std::string& name);
+
+    Type* build(const std::string& keyword, const eckit::Value&);
+
+    void list(std::ostream& s);
+};
+
+/// A self-registering factory for producing TypesFactory instances
+
+class TypesFactory {
+public:
+
+    virtual Type* make(const std::string& keyword, const eckit::Value& settings) const = 0;
+
+    static Type* build(const std::string& keyword, const eckit::Value& settings);
+
+    static void list(std::ostream& s);
+
+protected:
+
+    TypesFactory(const std::string&);
+
+    ~TypesFactory();
+
+    std::string name_;
+};
+
+/// Templated specialisation of the self-registering factory,
+/// that does the self-registration, and the construction of each object.
+
+template <class T>
+class TypeBuilder : public TypesFactory {
+    Type* make(const std::string& keyword, const eckit::Value& settings) const override {
+        return new T(keyword, settings);
+    }
+
+public:
+
+    TypeBuilder(const std::string& name) : TypesFactory(name) {}
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace mars
+}  // namespace metkit
+
+#endif