metkitlib 1.16.0.9__cp312-cp312-manylinux_2_28_aarch64.whl

metkitlib/__init__.py

@@ -0,0 +1,3 @@
+__version__ = '1.16.0.9'
+__commit_hash__ = 'f104efea40d66180a4c57f092ab5836d2f9dd084'
+findlibs_dependencies = ["eckitlib", "eccodeslib"]

metkitlib/bin/compare-mars-requests.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+
+# (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.
+
+# Emanuele Danovaro - ECMWF May 2021
+
+import sys
+import os.path
+import json
+import datetime
+from dateutil.parser import parse
+
+def check_one(name, old, new):
+    assert len(old) == 1 and len(new) == 1, f"{name.upper()}: too many values {len(old)} and {len(new)}"
+    return old[0], new[0]
+
+def check_atMostOne(name, old, new):
+    assert len(old) < 2 and len(new) < 2, f"{name.upper()}: too many values {len(old)} and {len(new)}"
+    return old[0] if 0 < len(old) else None, new[0] if 0 < len(new) else None
+
+def compare_int(name, old, new):
+    for o, n in zip(old, new):
+        assert str(o).isnumeric() and str(n).isnumeric() and int(o) == int(n), f"{name.upper()}: value mismatch '{old}' and '{new}'"
+
+def compare_float(name, old, new):
+    for o, n in zip(old, new):
+        try:
+            o = float(o)
+        except ValueError:
+            o = o.lower()
+
+        try:
+            n = float(n)
+        except ValueError:
+            n = n.lower()
+
+        assert o == n, f"{name.upper()}: value mismatch '{old}' and '{new}'"
+
+def compare_intAndKeywords(name, old, new, keywords):
+    o, n = check_atMostOne(name, old, new)
+    if o in keywords or str(o).lower() in keywords:
+        o = str(o).lower() if isinstance(o, str) else None
+    if n in keywords or str(n).lower() in keywords:
+        n = str(n).lower() if isinstance(n, str) else None
+    assert o == n or (str(o).isnumeric() and str(n).isnumeric() and int(o) == int(n)), f"{name.upper()}: value mismatch '{old}' and '{new}'"
+
+def compare_grid(name, old, new):
+    for o, n in zip(old, new):
+        try:
+            o = float(o)
+        except ValueError:
+            o = o.lower()
+
+        try:
+            n = float(n)
+        except ValueError:
+            n = n.lower()
+        assert o == n, f"{name.upper()}: value mismatch '{old}' and '{new}'"
+
+def compare_expect(name, old, new):
+    # 'any' or a positive integer value
+    compare_intAndKeywords(name, old, new, ["any"])
+
+def compare_accuracy(name, old, new):
+    # 'off', 'av' or a positive integer value
+    compare_intAndKeywords(name, old, new, [None, "off", "av", "n"])
+
+def compare_frame(name, old, new):
+    # 'off' or a positive integer value
+    compare_intAndKeywords(name, old, new, ["off"])
+
+def compare_truncation(name, old, new):
+    # 'none', 'auto', 'off' or a positive integer value
+    compare_intAndKeywords(name, old, new, ["off", "none", "auto"])
+
+def compare_step(name, old, new):
+    for o, n in zip(old, new):
+        oParts = str(o).split('-')
+        nParts = str(n).split('-')
+        assert len(oParts) == len(nParts) and all(float(oi) == float(ni) for oi, ni in zip(oParts, nParts)), f"{name.upper()}: value mismatch '{old}' and '{new}'"
+
+def compare_str(name, old, new):
+    o, n = check_one(name, old, new)
+    assert o.replace('"', '').lower() == n.replace('"', '').lower(), f"{name.upper()}: string mismatch '{old[0]}' and '{new[0]}'"
+
+def compare_strList(name, old, new):
+    for o, n in zip(old, new):
+        compare_str(name, [o], [n])
+
+def compare_strCaseSensitive(name, old, new):
+    for o, n in zip(old, new):
+        assert o.replace('"', '') == n.replace('"', ''), f"{name.upper()}: string mismatch '{old}' and '{new}'"
+
+def compare_time(name, old, new):
+    o, n = check_one(name, old, new)
+
+    if isinstance(o, str):
+        o = int(o.replace(':', ''))
+    if o>9999:
+        o = o/100
+
+    if isinstance(n, str):
+        n = int(n.replace(':', ''))
+    if n > 9999:
+        n = n / 100
+
+    assert o == n, f"{name.upper()}: time mismatch '{old[0]}' and '{new[0]}'"
+
+def compare_date(name, old, new):
+    o, n = check_one(name, old, new)
+    oStart = parse(str(o), default=datetime.datetime(1901, 1, 1))
+    oEnd = parse(str(o), default=datetime.datetime(2001, 12, 31))
+    nStart = parse(str(n), default=datetime.datetime(1901, 1, 1))
+    nEnd = parse(str(n), default=datetime.datetime(2001, 12, 31))
+    assert oStart.date() == nStart.date() and oEnd.date() == nEnd.date(), f"{name.upper()}: date mismatch '{old[0]}' and '{new[0]}'"
+
+def compare_dates(name, old, new):
+    for o, n in zip(old, new):
+        oStart = parse(str(o), default=datetime.datetime(1901, 1, 1))
+        oEnd = parse(str(o), default=datetime.datetime(2001, 12, 31))
+        nStart = parse(str(n), default=datetime.datetime(1901, 1, 1))
+        nEnd = parse(str(n), default=datetime.datetime(2001, 12, 31))
+        assert oStart.date() == nStart.date() and oEnd.date() == nEnd.date(), f"{name.upper()}: date mismatch '{o}' and '{n}'"
+
+def compare_expver(name, old, new):
+    o, n = check_one(name, old, new)
+    if isinstance(o, str):
+        try:
+            o = int(o)
+        except ValueError:
+            o = o.lower()
+
+    if isinstance(n, str):
+        try:
+            n = int(n)
+        except ValueError:
+            n = n.lower()
+
+    assert o == n, f"{name.upper()}: mismatch '{old[0]}' and '{new[0]}'"
+
+def ignore(name, old, new):
+    pass
+
+def ignore_fixYaml(name, old, new):
+    pass
+
+comparators = {
+    "accuracy": ignore_fixYaml, # ?????
+    # "accuracy": compare_accuracy,
+    "anoffset": compare_int, # ?????
+    "area": ignore_fixYaml,
+    "bitmap": compare_strCaseSensitive,
+    # block
+    # channel
+    "class": compare_str,
+    "database": compare_str, # ?????
+    "date": compare_date,
+    "diagnostic": compare_int, # ??????
+    "direction": compare_int, # should we handle case "all"
+    "domain": compare_str,
+    "duplicates": compare_str, # can we ignore ?
+    "expect": compare_expect,
+    "expver": compare_expver,
+    "fcmonth": compare_int,
+    "fcperiod": compare_step, # ??????
+    "fieldset": compare_strCaseSensitive,
+    "filter": compare_str,
+    "format": compare_str, # ?????
+    "frame": compare_frame,
+    "frequency": compare_int, # ??????
+    "grid": compare_grid,
+    "hdate": compare_dates,
+    "ident": compare_int,
+    "interpolation": compare_str,
+    # "intgrid":
+    "iteration": compare_int, # ??????
+    "latitude": compare_float,
+    "levelist": compare_float,
+    "levtype": compare_str,
+    "longitude": compare_float,
+    "lsm": compare_str, # ?????
+    "method": compare_int,
+    "number": compare_int,
+    "obsgroup": compare_str, # ?????
+    "obstype": compare_int,
+    "origin": compare_expver, # ?????
+    "packing": compare_str,
+    "padding": compare_int, # ??????
+    "param": compare_float, # <-- to check that short names have been replaced, otherwise we can use compare_strList
+    "priority": compare_int,
+    "product": compare_str, # ?????
+    "range": compare_int,
+    "refdate": compare_date,
+    "reference": compare_int,
+    "reportype": compare_int,
+    "repres": ignore,
+    # resol
+    "rotation": compare_grid,
+    "section": compare_str,
+    "source": compare_strCaseSensitive,
+    "step": compare_step,
+    "stream": compare_str,
+    "system": compare_int,
+    "target": compare_strCaseSensitive,
+    "time": compare_time,
+    "truncation": compare_truncation,
+    "type": compare_str,
+    "use": compare_str
+}
+
+def compare(name, old, new):
+    if not isinstance(old, list):
+        old = [old]
+    if not isinstance(new, list):
+        new = [new]
+
+    assert len(old) == len(new), f"{name}: list mismatch {len(old)} and {len(new)}"
+    assert name in comparators.keys(), f"{name}: not supported"
+    comparators[name](name, old, new)
+
+# compare_date('date', '20210501', '2021-05-01')
+# compare_date('date', '20210501', '2021-May-01')
+# compare_date('date', '20210501', '2021-may-01')
+# compare_date('date', 'May-1', 'may-01')
+# compare_date('date', 'May', 'may')
+# compare_date('date', 'May', '20210521')
+
+# check command line parameters
+if len(sys.argv) != 3 or not os.path.isfile(sys.argv[1]) or not os.path.isfile(sys.argv[2]):
+    print('Please specify the json files to be compared.')
+    print('Usage: ',sys.argv[0], '<first.json> <second.json>')
+    if len(sys.argv)>1 and not os.path.isfile(sys.argv[1]):
+        print(sys.argv[1], 'is not a file')
+    if len(sys.argv)>2 and not os.path.isfile(sys.argv[2]):
+        print(sys.argv[2], 'is not a file')
+    exit(1)
+
+#open json files and build case insensitive dictionaries
+json_lines_1 = []
+with open(sys.argv[1]) as json_file:
+    for line in json_file:
+        j = {}
+        for key, value in json.loads(line).items():
+            j[key.lower()] = value
+        json_lines_1.append(j)
+
+json_lines_2 = []
+with open(sys.argv[2]) as json_file:
+    for line in json_file:
+        j = {}
+        for key, value in json.loads(line).items():
+            j[key.lower()] = value
+        json_lines_2.append(j)
+
+assert len(json_lines_1) == len(json_lines_2), f"Json mismatch: {sys.argv[1]} contains {len(json_lines_1)} while {sys.argv[2]} contains {len(json_lines_2)}"
+
+for j1, j2 in zip(json_lines_1, json_lines_2):
+    for key in set(j1.keys()) | set(j2.keys()):
+        compare(key, j1.get(key), j2.get(key))

metkitlib/include/metkit/api/metkit_c.h

@@ -0,0 +1,255 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ---------------------------------------------------------------------------------------------------------------------
+ * TYPES
+ * -----*/
+
+struct metkit_marsrequest_t;
+typedef struct metkit_marsrequest_t metkit_marsrequest_t;
+
+struct metkit_requestiterator_t;
+/** RequestIterator for iterating over vector of Request instances */
+typedef struct metkit_requestiterator_t metkit_requestiterator_t;
+
+struct metkit_paramiterator_t;
+/** Iterator for iterating over parameters in Request */
+typedef struct metkit_paramiterator_t metkit_paramiterator_t;
+
+/* ---------------------------------------------------------------------------------------------------------------------
+ * ERROR HANDLING
+ * -------------- */
+
+typedef enum metkit_error_values_t {
+    METKIT_SUCCESS       = 0, /* Operation succeded. */
+    METKIT_ERROR         = 1, /* Operation failed. */
+    METKIT_ERROR_UNKNOWN = 2, /* Failed with an unknown error. */
+    METKIT_ERROR_USER    = 3, /* Failed with an user error. */
+    METKIT_ERROR_ASSERT  = 4  /* Failed with an assert() */
+} metkit_error_t;
+
+typedef enum metkit_iterator_status_t {
+    METKIT_ITERATOR_SUCCESS  = 0, /* Operation succeded. */
+    METKIT_ITERATOR_COMPLETE = 1, /* All elements have been returned */
+    METKIT_ITERATOR_ERROR    = 2  /* Operation failed. */
+} metkit_iterator_status_t;
+
+
+const char* metkit_get_error_string(enum metkit_error_values_t err);
+
+/* -----------------------------------------------------------------------------
+ * HELPERS
+ * ------- */
+
+/**
+ * @brief Get metkit version.
+ *
+ * @return const char* version string
+ */
+const char* metkit_version();
+
+/**
+ * @brief Get metkit git sha1 version.
+ *
+ * @return const char* git sha1 version string
+ */
+const char* metkit_git_sha1();
+
+/**
+ * @brief Initialise Main() context.
+ *
+ * @note This is ONLY required when Main() is NOT initialised, such as loading
+ * the MetKit as shared library in Python.
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_initialise();
+
+/* ---------------------------------------------------------------------------------------------------------------------
+ * PARSING
+ * --- */
+
+/**
+ * Parse MARS requests into RequestIterator of Request instances. Resulting RequestIterator
+ * must be deallocated with metkit_delete_requestiterator
+ * @param str MARS requests
+ * @param[out] requests Allocates RequestIterator object
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_parse_marsrequests(const char* str, metkit_requestiterator_t** requests, bool strict);
+
+/**
+ * Parse MARS request into Request instance
+ * @note will error if request expands to multiple requests: use metkit_parse_marsrequests instead
+ * @param str MARS request
+ * @param[out] request Request instance
+ * @param strict if true, raise error rather than warning on invalid values
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_parse_marsrequest(const char* str, metkit_marsrequest_t* request, bool strict);
+/* ---------------------------------------------------------------------------------------------------------------------
+ * REQUEST
+ * --- */
+
+/** Allocates new Request object. Must be deallocated with mekit_delete_request
+ * @param[out] request new Request instance
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_new(metkit_marsrequest_t** request);
+
+/** Deallocates Request object and associated resources.
+ * @param request Request instance
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_delete(const metkit_marsrequest_t* request);
+
+/** Add parameter and values to request
+ * @param request Request instance
+ * @param param parameter name
+ * @param values array of values for parameter
+ * @param numValues number of values
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_set(metkit_marsrequest_t* request, const char* param, const char* values[],
+                                      int numValues);
+
+/** Add parameter and values to request
+ * @param request Request instance
+ * @param param parameter name
+ * @param values value to add
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_set_one(metkit_marsrequest_t* request, const char* param, const char* value);
+
+/** Set verb in Request object
+ * @param request Request instance
+ * @param verb verb to set
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_set_verb(metkit_marsrequest_t* request, const char* verb);
+
+/** Returns the verb in Request object
+ * @param request Request instance
+ * @param[out] verb verb in request
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_verb(const metkit_marsrequest_t* request, const char** verb);
+
+/** Returns whether parameter is in Request object
+ * @param request Request instance
+ * @param param parameter name
+ * @param[out] has whether parameter exists in request
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_has_param(const metkit_marsrequest_t* request, const char* param, bool* has);
+
+
+/** Returns parameter iterator for Request object
+ * Must be deallocated with metkit_paramiterator_delete
+ * @note: The strings obtained from next() are owned by the iterator and should be copied if they need to outlive it.
+ * @param request Request instance
+ * @param[out] params parameter iterator
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_params(const metkit_marsrequest_t* request, metkit_paramiterator_t** params);
+
+
+/** Returns number of values for specific parameter in Request object
+ * @param request Request instance
+ * @param param parameter name in request
+ * @param[out] count number of values for param in request
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_count_values(const metkit_marsrequest_t* request, const char* param, size_t* count);
+
+/** Returns value for specific parameter and index in Request object
+ * @param request Request instance
+ * @param param parameter name in request
+ * @param index index of value to retrieve for param in request
+ * @param[out] value retrieved value
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_value(const metkit_marsrequest_t* request, const char* param, int index,
+                                        const char** value);
+
+/** Populates empty Request object by expanding existing request
+ * @param request Request instance to be expanded
+ * @param inherit if true, populate expanded request with default values
+ * @param strict it true, raise error rather than warning on invalid values
+ * @param[out] expandedRequest empty Request instance to be populated
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_expand(const metkit_marsrequest_t* request, bool inherit, bool strict,
+                                         metkit_marsrequest_t* expandedRequest);
+
+/** Merges other Request object into existing request
+ * @param request Request instance to contain result of merge
+ * @param otherRequest other Request instance to merge
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_marsrequest_merge(metkit_marsrequest_t* request, const metkit_marsrequest_t* otherRequest);
+
+/* ---------------------------------------------------------------------------------------------------------------------
+ * REQUEST ITERATOR
+ * --- */
+
+/** Deallocates RequestIterator object and associated resources.
+ * @param it RequestIterator instance
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_requestiterator_delete(const metkit_requestiterator_t* it);
+
+/** Moves to the next Request element in RequestIterator
+ * @param it RequestIterator instance
+ * @return metkit_iterator_status_t Status of iterator
+ */
+// metkit_error_t metkit_requestiterator_next(metkit_requestiterator_t* it);
+metkit_iterator_status_t metkit_requestiterator_next(metkit_requestiterator_t* it);
+
+/** Populates empty Request object with data from current element in RequestIterator
+ * @param it RequestIterator instance
+ * @param request empty Request instance to populate with data
+ * @return metkit_iterator_status_t Status of iterator
+ * @note must call metkit_requestiterator_next before calling metkit_requestiterator_current.
+ *
+ * Example usage:
+ * while (metkit_requestiterator_next(it) == METKIT_ITERATOR_SUCCESS) {
+ *     metkit_marsrequest_t* req{};
+ *     metkit_marsrequest_new(&req);
+ *     metkit_requestiterator_current(it, req);
+ *     // use req ...
+ * }
+ */
+metkit_iterator_status_t metkit_requestiterator_current(metkit_requestiterator_t* it, metkit_marsrequest_t* request);
+
+/* ---------------------------------------------------------------------------------------------------------------------
+ * PARAMETER ITERATOR
+ * --- */
+
+/** Deallocates ParamIterator object and the char* strings it owns.
+ * @param it ParamIterator instance
+ * @return metkit_error_t Error code
+ */
+metkit_error_t metkit_paramiterator_delete(const metkit_paramiterator_t* it);
+
+/** Moves to the next parameter in ParamIterator
+ * @param it ParamIterator instance
+ * @return metkit_iterator_status_t Status of iterator
+ */
+metkit_iterator_status_t metkit_paramiterator_next(metkit_paramiterator_t* it);
+
+/** Returns current parameter in ParamIterator
+ * @param it ParamIterator instance
+ * @param[out] param current parameter
+ * @return metkit_iterator_status_t Status of iterator
+ */
+metkit_iterator_status_t metkit_paramiterator_current(const metkit_paramiterator_t* it, const char** param);
+
+#ifdef __cplusplus
+}
+#endif

metkitlib/include/metkit/codes/BUFRDecoder.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.
+ */
+
+/// @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 {
+namespace codes {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class BUFRDecoder : public eckit::message::MessageDecoder {
+
+public:  // methods
+
+    static bool typeBySubtype(long subtype, long& type);
+
+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 codes
+}  // namespace metkit

metkitlib/include/metkit/codes/BufrContent.h

@@ -0,0 +1,43 @@
+/*
+ * (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 Emanuele Danovaro
+/// @date   Mar 2022
+
+#pragma once
+
+#include "metkit/codes/CodesContent.h"
+
+namespace metkit {
+namespace codes {
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class BufrContent : public CodesContent {
+public:
+
+    BufrContent(codes_handle* handle, bool delete_handle);
+    explicit BufrContent(const codes_handle* handle);
+
+    ~BufrContent();
+
+protected:
+
+    using CodesContent::transform;
+    void transform(const eckit::OrderedStringDict& dict) override;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+
+}  // namespace codes
+}  // namespace metkit

metkitlib/include/metkit/codes/CodesContent.h

@@ -0,0 +1,67 @@
+/*
+ * (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   Jun 2020
+
+#pragma once
+
+#include "eckit/message/MessageContent.h"
+
+typedef struct grib_handle codes_handle;
+
+namespace metkit {
+namespace codes {
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class CodesContent : public eckit::message::MessageContent {
+public:
+
+    CodesContent(codes_handle* handle, bool delete_handle);
+    explicit CodesContent(const codes_handle* handle);
+
+    ~CodesContent();
+
+protected:
+
+    codes_handle* handle_;
+
+    using eckit::message::MessageContent::transform;
+    void transform(const eckit::OrderedStringDict&) override;
+
+private:
+
+    bool delete_handle_;
+
+    size_t length() const override;
+    void write(eckit::DataHandle& handle) const override;
+    eckit::DataHandle* readHandle() const override;
+    void print(std::ostream& s) const override;
+    std::string getString(const std::string& key) const override;
+    long getLong(const std::string& key) const override;
+    double getDouble(const std::string& key) const override;
+    void getDoubleArray(const std::string& key, std::vector<double>& values) const override;
+    void getFloatArray(const std::string& key, std::vector<float>& values) const override;
+    size_t getSize(const std::string& key) const override;
+    void getDoubleArray(const std::string& key, double* data, size_t lenExpected) const override;
+    void getFloatArray(const std::string& key, float* data, size_t lenExpected) const override;
+
+    eckit::Offset offset() const override;
+    const codes_handle* codesHandle() const;
+    const void* data() const override;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace codes
+}  // namespace metkit