metkitlib 1.16.0.9__cp312-cp312-manylinux_2_28_aarch64.whl

metkitlib/include/metkit/codes/CodesHandleDeleter.h

@@ -0,0 +1,41 @@
+/*
+ * (C) Copyright 2022- 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 Philipp Geier
+/// @author Simon Smart
+/// @date   Nov 2022
+
+#pragma once
+
+#include <eccodes.h>
+#include <memory>
+
+//----------------------------------------------------------------------------------------------------------------------
+
+namespace std {
+
+template <>
+struct default_delete<codes_handle> {
+    void operator()(codes_handle* h) { ::codes_handle_delete(h); }
+};
+
+template <>
+struct default_delete<codes_keys_iterator> {
+    void operator()(codes_keys_iterator* it) { ::codes_keys_iterator_delete(it); }
+};
+
+template <>
+struct default_delete<codes_bufr_keys_iterator> {
+    void operator()(codes_bufr_keys_iterator* it) { ::codes_bufr_keys_iterator_delete(it); }
+};
+
+}  // namespace std
+
+//----------------------------------------------------------------------------------------------------------------------

metkitlib/include/metkit/codes/CodesSplitter.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.
+ */
+
+/// @author Baudouin Raoult
+/// @date   Jun 2020
+
+#pragma once
+
+#include "eckit/message/Splitter.h"
+
+
+namespace metkit {
+namespace codes {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class CodesSplitter : public eckit::message::Splitter {
+public:
+
+    CodesSplitter(eckit::PeekHandle&);
+    ~CodesSplitter();
+
+private:  // methods
+
+    eckit::message::Message next() override;
+    void print(std::ostream&) const override;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace codes
+}  // namespace metkit

metkitlib/include/metkit/codes/GRIBDecoder.h

@@ -0,0 +1,42 @@
+/*
+ * (C) Copyright 2020- 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   Jun 2020
+
+#pragma once
+
+#include "eckit/message/Decoder.h"
+#include "eckit/message/Message.h"
+
+#include "eckit/io/Buffer.h"
+
+namespace metkit::codes {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class GRIBDecoder : public eckit::message::MessageDecoder {
+public:  // methods
+
+private:  // methods
+
+    bool match(const eckit::message::Message&) const override;
+    void print(std::ostream&) const override;
+
+    void getMetadata(const eckit::message::Message& msg, eckit::message::MetadataGatherer&,
+                     const eckit::message::GetMetadataOptions&) const override;
+
+    eckit::Buffer decode(const eckit::message::Message& msg) const override;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::codes

metkitlib/include/metkit/codes/GribAccessor.h

@@ -0,0 +1,75 @@
+/*
+ * (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.
+ */
+
+#pragma once
+
+#include "eckit/exception/Exceptions.h"
+#include "eckit/log/Log.h"
+#include "metkit/codes/GribHandle.h"
+
+namespace metkit {
+namespace grib {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class GribAccessorBase {
+
+protected:
+
+    void grib_get_value(const GribHandle& h, const std::string& name, double& x, bool quiet = false) const;
+
+    void grib_get_value(const GribHandle& h, const std::string& name, unsigned long& x, bool quiet = false) const;
+
+    void grib_get_value(const GribHandle& h, const std::string& name, long& x, bool quiet = false) const;
+
+    void grib_get_value(const GribHandle& h, const std::string& name, bool& x, bool quiet = false) const;
+
+    void grib_get_value(const GribHandle& h, const std::string& name, std::string& x, bool quiet = false) const;
+
+    void grib_get_value(const GribHandle& h, const std::string& name, std::vector<long>& x, bool quiet = false) const;
+
+    void grib_get_value(const GribHandle& h, const std::string& name, std::vector<double>& x, bool quiet = false) const;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+template <class T>
+class GribAccessor : private GribAccessorBase {
+
+private:  // members
+
+    std::string name_;
+    bool quiet_;
+
+public:  // methods
+
+    GribAccessor(const std::string& name, bool quiet = false) : name_(name), quiet_(quiet) {}
+
+    T value(const GribHandle& h) const {
+        T value;
+        grib_get_value(h, name_, value, quiet_);
+        return value;
+    }
+
+    T value(const GribHandle& h, T def) const {
+        T value = def;
+        grib_get_value(h, name_, value, true);
+        return value;
+    }
+
+    T operator()(const GribHandle& h) const { return value(h); }
+
+    T operator()(const GribHandle& h, T def) const { return value(h, def); }
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace grib
+}  // namespace metkit

metkitlib/include/metkit/codes/GribHandle.h

@@ -0,0 +1,121 @@
+/*
+ * (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.
+ */
+
+#pragma once
+
+#include "eckit/filesystem/PathName.h"
+#include "eckit/io/Buffer.h"
+#include "eckit/log/CodeLocation.h"
+#include "eckit/memory/NonCopyable.h"
+
+struct grib_handle;
+
+namespace eckit {
+class DataHandle;
+}
+
+namespace metkit {
+namespace grib {
+
+class GribMetaData;
+class GribAccessorBase;
+class GribMutatorBase;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+void codes_call(int code, const char* msg, const eckit::CodeLocation& where);
+
+#define CODES_CALL(a) metkit::grib::codes_call(a, #a, Here())
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class GribHandle : private eckit::NonCopyable {
+
+public:  // types
+
+    /// constructor from file path, creates grib_handle and takes ownership
+    /// @note currently this only handles local paths
+    explicit GribHandle(const eckit::PathName&);
+
+    /// constructor taking ownership of a grib_handle pointer
+    GribHandle(grib_handle*);
+
+    /// constructor not taking
+    GribHandle(grib_handle&);
+
+    /// constructor creating a grib_handle from a DataHandle
+    explicit GribHandle(eckit::DataHandle&);
+
+    // Constructor creating a grib_handle from a DataHandle starting from a given offset
+    explicit GribHandle(eckit::DataHandle&, eckit::Offset);
+
+    /// destructor will delete the grib_handle if we own it
+    ~GribHandle() noexcept(false);
+
+public:  // methods
+
+    size_t length() const;
+
+    // std::string gridType() const;
+
+    std::string geographyHash() const;
+
+    GribHandle* clone() const;
+
+    // std::string shortName() const;
+
+    // size_t numberOfPoints() const;
+
+    size_t getDataValuesSize() const;
+    double* getDataValues(size_t&) const;
+    void getDataValues(double*, const size_t&) const;
+
+    void setDataValues(const double*, size_t);
+
+    size_t write(eckit::DataHandle&) const;
+    size_t write(eckit::Buffer&) const;
+    void write(const eckit::PathName&, const char* mode = "w") const;
+    void dump(const eckit::PathName&, const char* mode = "debug") const;
+
+    // double latitudeOfFirstGridPointInDegrees()  const;
+    // double longitudeOfFirstGridPointInDegrees() const;
+    // double latitudeOfLastGridPointInDegrees()   const;
+    // double longitudeOfLastGridPointInDegrees()  const;
+
+    bool hasKey(const char*) const;
+
+    operator const grib_handle*() const { return handle_; }
+
+protected:  // methods
+
+    friend class GribAccessorBase;
+    friend class GribMutatorBase;
+    friend class GribIterator;
+
+    /// To be used by friends since this is rather dangerous
+    /// Don't delete this pointer, use with care :)
+    /// @returns the raw grib_handle so client code can call grib directly
+
+    grib_handle* raw() const { return handle_; }
+
+    /// Client code shouldn't care if GRIB edition
+    long edition() const;
+
+private:  // members
+
+    grib_handle* handle_;
+
+    bool owned_;
+};
+
+//------------------------------------------------------------------------------------------------------
+
+}  // namespace grib
+}  // namespace metkit

metkitlib/include/metkit/codes/GribIterator.h

@@ -0,0 +1,48 @@
+/*
+ * (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.
+ */
+
+#pragma once
+
+#include "eckit/filesystem/PathName.h"
+#include "eckit/io/Buffer.h"
+#include "eckit/log/CodeLocation.h"
+#include "eckit/memory/NonCopyable.h"
+
+struct grib_iterator;
+
+namespace eckit {
+class DataHandle;
+}
+
+namespace metkit {
+namespace grib {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class GribHandle;
+
+class GribIterator : private eckit::NonCopyable {
+public:
+
+    GribIterator(const GribHandle&);
+    ~GribIterator() noexcept(false);
+
+
+    bool next(double& lat, double& lon, double& value);
+
+private:  // members
+
+    grib_iterator* iterator_;
+};
+
+//------------------------------------------------------------------------------------------------------
+
+}  // namespace grib
+}  // namespace metkit

metkitlib/include/metkit/codes/LibEccodes.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.
+ */
+
+/// @author Olivier Iffrig
+/// @date   October 2019
+
+#pragma once
+
+#include "eckit/system/Library.h"
+
+namespace metkit {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class LibEccodes : public eckit::system::Library {
+public:
+
+    LibEccodes();
+
+    static const LibEccodes& instance();
+
+protected:
+
+    std::string version() const override;
+
+    std::string gitsha1(unsigned int count) const override;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit

metkitlib/include/metkit/codes/MallocCodesContent.h

@@ -0,0 +1,46 @@
+/*
+ * (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
+/// @author Tiago Quintino
+/// @date   Jun 2020
+
+#pragma once
+
+#include "eckit/io/Offset.h"
+#include "metkit/codes/CodesContent.h"
+
+
+namespace metkit {
+namespace codes {
+
+class MallocCodesContent : public CodesContent {
+public:
+
+    MallocCodesContent(void* data, size_t size, const eckit::Offset& offset);
+    ~MallocCodesContent();
+
+private:  // methods
+
+    void print(std::ostream& s) const override;
+    eckit::Offset offset() const override;
+    const void* data() const override;
+    size_t length() const override;
+
+private:  // members
+
+    void* buffer_;
+    size_t length_;
+    eckit::Offset offset_;
+};
+
+
+}  // namespace codes
+}  // namespace metkit