metkitlib 1.16.0.9__cp312-cp312-manylinux_2_28_aarch64.whl

metkitlib/include/metkit/codes/api/KeyIterator.h

@@ -0,0 +1,187 @@
+/*
+ * (C) Copyright 2025- 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.
+ */
+
+#pragma once
+
+#include "metkit/codes/api/CodesTypes.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+
+namespace metkit::codes {
+
+/// A namepspace is defined through the definition files and represented as a string.
+using Namespace = std::string;
+
+
+/// Commonly used eccodes namespacess.
+namespace namespaces {
+
+/// LS namespace contains a collection of descriptive keys as used by `grib_ls`.
+const Namespace ls{"ls"};
+
+const Namespace parameter{"parameter"};
+const Namespace statistics{"statistics"};
+const Namespace time{"time"};
+const Namespace geography{"geography"};
+const Namespace vertical{"vertical"};
+
+/// MARS namespace contains keys used for indexation
+const Namespace mars{"mars"};
+
+};  // namespace namespaces
+
+/// Flag to control/filter key iterator.
+///
+/// Use `AllKeys` to disable filtering.
+/// Use combination of `Skip*` to filter.
+enum class KeyIteratorFlags : unsigned int {
+    /// Default - Will iterate all keys in a namespace.
+    AllKeys             = 0,
+    SkipReadOnly        = 1 << 0,
+    SkipOptional        = 1 << 1,
+    SkipEditionSpecific = 1 << 2,
+    SkipCoded           = 1 << 3,
+    SkipComputed        = 1 << 4,
+    SkipDuplicates      = 1 << 5,
+    SkipFunction        = 1 << 6,
+};
+
+KeyIteratorFlags operator|(KeyIteratorFlags a, KeyIteratorFlags b);
+KeyIteratorFlags operator&(KeyIteratorFlags a, KeyIteratorFlags b);
+KeyIteratorFlags operator^(KeyIteratorFlags a, KeyIteratorFlags b);
+KeyIteratorFlags operator~(KeyIteratorFlags a);
+
+/// Optional helper to check if a flag is set.
+bool hasFlag(KeyIteratorFlags value, KeyIteratorFlags flag);
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class KeyRange;
+
+/// Abstract interface wrapping C API calls on on key_iterator.
+class KeyIterator {
+    friend class KeyRange;
+
+public:
+
+    virtual ~KeyIterator() = default;
+
+    /// Get the name of the iterated key.
+    /// @return Name of the iterated key.
+    virtual std::string name() const = 0;
+
+    /// Get the value of the key.
+    ///
+    /// High-level functionality:
+    /// Inspection on the contained valued is performed with `type` and `size`.
+    /// Then the more specific `getXXX` call is performed.
+    /// @return Variant of all possible value types.
+    virtual CodesValue get() const = 0;
+
+    /// Get the type of the iterated key.
+    /// @return Type of the iterated key.
+    virtual NativeType type() const = 0;
+
+    /// Get the contained value for a key as long.
+    /// @return Retrieved value contained for the iterated key.
+    virtual long getLong() const = 0;
+
+    /// Get the contained value for a key as double.
+    /// @return Retrieved value contained for the iterated key.
+    virtual double getDouble() const = 0;
+
+    /// Get the contained value for a key as float.
+    /// @return Retrieved value contained for the iterated key.
+    virtual float getFloat() const = 0;
+
+    /// Get the contained value for a key as string.
+    ///
+    /// This should be possible for all key types.
+    /// @return Retrieved value contained for the iterated key.
+    virtual std::string getString() const = 0;
+
+    /// Get the contained values for a key as array of long.
+    /// @return Retrieved values contained for the iterated key.
+    virtual std::vector<long> getLongArray() const = 0;
+
+    /// Get the contained values for a key as array of double.
+    /// @return Retrieved values contained for the iterated key.
+    virtual std::vector<double> getDoubleArray() const = 0;
+
+    /// Get the contained values for a key as array of float.
+    /// @return Retrieved values contained for the iterated key.
+    virtual std::vector<float> getFloatArray() const = 0;
+
+    /// Get the contained values for a key as array of string.
+    /// @return Retrieved values contained for the iterated key.
+    virtual std::vector<std::string> getStringArray() const = 0;
+
+    /// Get the contained values for a key as array of uint8_t (bytes).
+    /// @return Retrieved values contained for the iterated key.
+    virtual std::vector<std::uint8_t> getBytes() const = 0;
+
+
+protected:
+
+    /// Iterates the next element.
+    virtual void next() = 0;
+
+    /// Check if the iterator is valid.
+    /// @return True if the iterator is still valid and holds a value. False indicates end of iteration.
+    virtual bool isValid() const = 0;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/// Implements the key iterator (codes_key_iterator) based on a C++ range.
+/// Enables use of range-based for-loop.
+class KeyRange {
+public:
+
+    struct EndIterator;
+
+    struct Iterator {
+        friend struct EndIterator;
+
+        Iterator& operator++() {
+            state->next();
+            return *this;
+        };
+        const KeyIterator& operator*() const { return *state; };
+        const KeyIterator* operator->() const { return state; };
+
+        inline bool operator!=(const KeyRange::EndIterator&) { return state->isValid(); }
+
+        KeyIterator* state;
+    };
+
+    struct EndIterator {
+        inline bool operator!=(const KeyRange::Iterator& it) { return it.state->isValid(); }
+    };
+
+    Iterator begin() const { return Iterator{impl_.get()}; };
+    EndIterator end() const { return {}; };
+
+    KeyRange(std::unique_ptr<KeyIterator> impl) : impl_{std::move(impl)} {};
+
+private:
+
+    std::unique_ptr<KeyIterator> impl_;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::codes

metkitlib/include/metkit/config/LibMetkit.h

@@ -0,0 +1,56 @@
+/*
+ * (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 Baudouin Raoult
+/// @author Tiago Quintino
+/// @date   August 2016
+
+#ifndef mir_LibMetkit_H
+#define mir_LibMetkit_H
+
+#include "eckit/filesystem/PathName.h"
+#include "eckit/system/Library.h"
+
+//----------------------------------------------------------------------------------------------------------------------
+
+namespace metkit {
+
+class LibMetkit : public eckit::system::Library {
+public:
+
+    LibMetkit();
+
+    static eckit::PathName configFile(const std::string& filename);
+
+    static eckit::PathName languageYamlFile();
+    static std::vector<eckit::PathName> modifiersYamlFiles();
+    static eckit::PathName paramYamlFile();
+    static eckit::PathName paramStaticYamlFile();
+    static eckit::PathName paramIDYamlFile();
+    static eckit::PathName paramMatchingYamlFile();
+    static eckit::PathName shortnameContextYamlFile();
+    static eckit::PathName bufrSubtypesYamlFile();
+
+    static const LibMetkit& instance();
+
+protected:
+
+    const void* addr() const;
+
+    virtual std::string version() const;
+
+    virtual std::string gitsha1(unsigned int count) const;
+};
+
+}  // namespace metkit
+
+//----------------------------------------------------------------------------------------------------------------------
+
+#endif

metkitlib/include/metkit/fields/FieldIndex.h

@@ -0,0 +1,58 @@
+/*
+ * (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.
+ */
+
+#ifndef metkit_FieldIndex_H
+#define metkit_FieldIndex_H
+
+#include "eckit/memory/NonCopyable.h"
+#include "eckit/serialisation/Stream.h"
+
+namespace eckit {
+namespace message {
+class Message;
+}
+}  // namespace eckit
+
+namespace metkit {
+namespace fields {
+
+class FieldIndex : private eckit::NonCopyable {
+public:
+
+    FieldIndex();
+    FieldIndex(const eckit::message::Message&);
+
+    FieldIndex(eckit::Stream&);
+
+    virtual ~FieldIndex();
+
+    void getValue(const std::string& name, double& value);
+    void getValue(const std::string& name, long& value);
+    void getValue(const std::string& name, std::string& value);
+
+    std::string substitute(const std::string& pattern) const;
+
+    void encode(eckit::Stream&) const;
+
+    void setValue(const std::string& name, double value);
+    void setValue(const std::string& name, long value);
+    void setValue(const std::string& name, const std::string& value);
+
+protected:  // members
+
+    std::map<std::string, std::string> stringValues_;
+    std::map<std::string, long> longValues_;
+    std::map<std::string, double> doubleValues_;
+};
+
+}  // namespace fields
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/fields/FieldIndexList.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.
+ */
+
+#ifndef metkit_FieldIndexList_H
+#define metkit_FieldIndexList_H
+
+#include "eckit/io/Offset.h"
+#include "eckit/serialisation/Stream.h"
+#include "eckit/types/Types.h"
+
+namespace metkit {
+namespace fields {
+
+class FieldIndex;
+
+class FieldIndexList {
+public:
+
+    ~FieldIndexList();
+
+    void readFrom(eckit::Stream& s);
+    void sendTo(eckit::Stream& s) const;
+
+    eckit::OffsetList offset_;
+    eckit::LengthList length_;
+    std::vector<FieldIndex*> fields_;
+};
+
+}  // namespace fields
+}  // namespace metkit
+
+
+#endif

metkitlib/include/metkit/fields/SimpleFieldIndex.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.
+ */
+
+#ifndef metkit_SimpleFieldIndex_H
+#define metkit_SimpleFieldIndex_H
+
+#include "metkit/fields/FieldIndex.h"
+namespace metkit {
+namespace fields {
+// struct grib_handle;
+
+class SimpleFieldIndex : public FieldIndex {
+public:
+
+    // -- Contructors
+
+    SimpleFieldIndex(eckit::Stream&);
+
+    // -- Destructor
+
+    virtual ~SimpleFieldIndex() override;
+
+    // -- Methods
+
+private:  // members
+
+    // friend std::ostream& operator<<(std::ostream& s,const SimpleFieldIndex& p)
+    //	{ p.print(s); return s; }
+};
+
+}  // namespace fields
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/hypercube/HyperCube.h

@@ -0,0 +1,105 @@
+/*
+ * (C) Copyright 2017- 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 Baudouin Raoult
+/// @date   Aug 2017
+
+
+#ifndef metkit_HyperCube_H
+#define metkit_HyperCube_H
+
+#include <iosfwd>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "eckit/utils/HyperCube.h"
+
+#include "metkit/config/LibMetkit.h"
+#include "metkit/mars/MarsRequest.h"
+
+
+namespace metkit {
+namespace hypercube {
+
+class Axis;
+
+class AxisOrder {
+public:  // methods
+
+    static AxisOrder& instance();
+
+    const std::vector<std::string>& axes() { return axes_; }
+    size_t index(const std::string& axis) const;
+
+private:  // methods
+
+    AxisOrder();
+
+    eckit::PathName axisYamlFile() { return "~metkit/share/metkit/axis.yaml"; }
+
+private:  // members
+
+    std::vector<std::string> axes_;
+    std::map<std::string, size_t> axisIndex_;
+};
+
+class HyperCube {
+public:
+
+    HyperCube(const metkit::mars::MarsRequest&);
+    ~HyperCube();
+
+    bool contains(const metkit::mars::MarsRequest&) const;
+    bool clear(const metkit::mars::MarsRequest&);
+
+    size_t count() const;
+    size_t countVacant() const;
+    size_t size() const { return cube_.count(); }
+
+    size_t fieldOrdinal(const metkit::mars::MarsRequest&, bool noholes = true) const;
+    std::vector<metkit::mars::MarsRequest> vacantRequests() const { return aggregatedRequests(true); }
+    std::vector<metkit::mars::MarsRequest> requests() const { return aggregatedRequests(false); }
+
+protected:
+
+    std::vector<metkit::mars::MarsRequest> aggregatedRequests(bool remaining) const;
+    int indexOf(const metkit::mars::MarsRequest&) const;
+    bool clear(int index);
+    metkit::mars::MarsRequest requestOf(size_t index) const;
+
+    // Given a set of indices, build the *minimal* collection of Mars requests that cover them.
+    // Each entry in the result vector is: { merged_request, number_of_points_covered_by_that_request }
+    /// @note: This does not take into account whether the point is "set" or not
+    std::vector<std::pair<metkit::mars::MarsRequest, size_t>> request(const std::set<size_t>& idxs) const;
+
+private:
+
+    std::string verb_;
+    std::vector<Axis*> axes_;
+    std::map<std::string, Axis*> axesByName_;
+    std::vector<bool> set_;
+    eckit::HyperCube cube_;
+    size_t count_;
+
+
+    void print(std::ostream&) const;
+
+    friend std::ostream& operator<<(std::ostream& s, const HyperCube& p) {
+        p.print(s);
+        return s;
+    }
+};
+
+}  // namespace hypercube
+}  // namespace metkit
+
+
+#endif

metkitlib/include/metkit/hypercube/HyperCubePayloaded.h

@@ -0,0 +1,88 @@
+/*
+ * (C) Copyright 2017- 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 Emanuele Danovaro
+/// @date   Aug 2020
+
+
+#ifndef metkit_HyperCubePayloaded_H
+#define metkit_HyperCubePayloaded_H
+
+#include "metkit/hypercube/HyperCube.h"
+
+
+namespace metkit {
+namespace hypercube {
+
+template <typename T>
+class Deduplicator {
+public:
+
+    virtual bool toReplace(const T& existing, const T& replacement) const = 0;
+};
+
+template <typename T>
+class HyperCubePayloaded : public HyperCube {
+public:
+
+    HyperCubePayloaded(const metkit::mars::MarsRequest& request, const Deduplicator<T>& deduplicator) :
+        HyperCube(request), dedup_(deduplicator) {
+
+
+        // throw error for default dedup
+    }
+
+
+    void add(const metkit::mars::MarsRequest& request, T payload) {
+
+        int idx = indexOf(request);
+
+        ASSERT(0 <= idx && idx < size());
+
+        auto entry = entries_.find(idx);
+        if (entry == entries_.end()) {
+            entries_.emplace(idx, payload);
+            clear(idx);
+        }
+        else {
+            if (dedup_.toReplace(entry->second, payload)) {
+                entry->second = payload;
+            }
+        }
+    }
+
+    const T& at(size_t idx) {
+        ASSERT(0 <= idx);
+        ASSERT(idx < size());
+
+        return entries_[idx];
+    }
+
+    bool find(size_t idx, T& payload) {
+        auto it = entries_.find(idx);
+
+        if (it == entries_.end())
+            return false;
+
+        payload = it->second;
+        return true;
+    }
+
+private:
+
+    const Deduplicator<T>& dedup_;
+    std::map<size_t, T> entries_;
+};
+
+}  // namespace hypercube
+}  // namespace metkit
+
+
+#endif

metkitlib/include/metkit/mars/BaseProtocol.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.
+ */
+
+// File BaseProtocol.h
+// Baudouin Raoult - (c) ECMWF Feb 12
+
+#ifndef BaseProtocol_H
+#define BaseProtocol_H
+
+#include "eckit/io/Length.h"
+#include "eckit/serialisation/Streamable.h"
+
+namespace eckit {
+class Configuration;
+}
+
+namespace metkit {
+namespace mars {
+
+class MarsRequest;
+
+class BaseProtocol : public eckit::Streamable {
+
+public:
+
+    BaseProtocol();
+    BaseProtocol(eckit::Stream&);
+    BaseProtocol(const eckit::Configuration&);
+
+    virtual ~BaseProtocol() override;
+
+    virtual eckit::Length retrieve(const MarsRequest&)             = 0;
+    virtual void archive(const MarsRequest&, const eckit::Length&) = 0;
+
+    virtual long read(void* buffer, long len)        = 0;
+    virtual long write(const void* buffer, long len) = 0;
+    virtual void cleanup()                           = 0;
+
+    // -- Overridden methods (from Streamable)
+    static const eckit::ClassSpec& classSpec();
+
+protected:
+
+    virtual void print(std::ostream&) const = 0;
+    virtual void encode(eckit::Stream&) const override;
+
+private:
+
+    friend std::ostream& operator<<(std::ostream& s, const BaseProtocol& p) {
+        p.print(s);
+        return s;
+    }
+};
+
+
+class ProtocolFactory {
+
+    std::string name_;
+
+    virtual BaseProtocol* make(const eckit::Configuration&) = 0;
+
+protected:
+
+    ProtocolFactory(const std::string&);
+
+    virtual ~ProtocolFactory();
+
+public:
+
+    static BaseProtocol* build(const eckit::Configuration&);
+
+    static void list(std::ostream&);
+};
+
+
+template <class T>
+class ProtocolBuilder : public ProtocolFactory {
+    virtual BaseProtocol* make(const eckit::Configuration& param) override { return new T(param); }
+
+public:
+
+    ProtocolBuilder(const std::string& name) : ProtocolFactory(name) {}
+};
+
+}  // namespace mars
+}  // namespace metkit
+
+#endif