CodesHandle::getBytes: use length instead of size to determine array size

Author: pgeier

src/metkit/codes/BUFRDecoder.cc

@@ -114,6 +114,19 @@ void BUFRDecoder::getMetadata(const eckit::message::Message& msg, eckit::message
                         if constexpr (std::is_same_v<Type, std::string> || std::is_arithmetic_v<Type>) {
                             gather.setValue(name, std::forward<decltype(v)>(v));
                         }
+                        else if constexpr (std::is_same_v<Type, std::vector<uint8_t>>) {
+                            static const char hex_digits[] = "0123456789abcdef";
+                            std::string out;
+                            out.resize(v.size() * 2);
+
+                            for (size_t i = 0; i < v.size(); i++) {
+                                uint8_t b      = v[i];
+                                out[2 * i]     = hex_digits[b >> 4];
+                                out[2 * i + 1] = hex_digits[b & 0x0F];
+                            }
+
+                            gather.setValue(name, out);
+                        }
                         else {
                             // Unhandled types are all array types - the prior call checking `size != 1` only allows for
                             // scalars.

src/metkit/codes/GRIBDecoder.cc

@@ -17,11 +17,11 @@
 #include "metkit/codes/GRIBDecoder.h"
 #include "metkit/codes/api/CodesAPI.h"
 
+#include "eccodes.h"
+
 #include <algorithm>
 #include <iostream>
 
-#include "eccodes.h"
-
 
 namespace metkit {
 namespace codes {
@@ -63,29 +63,33 @@ void GRIBDecoder::getMetadata(const eckit::message::Message& msg, eckit::message
                 break;
             }
             case eckit::message::ValueRepresentation::Native: {
-                // https://jira.ecmwf.int/browse/ECC-2166
-                if (name == "uuidOfHGrid") {
-                    // uuidOfHGrid returns size 1 although it contains 16 bytes
-                    gather.setValue(name, k.getString());
-                }
-                else {
-                    std::visit(
-                        [&](auto&& v) {
-                            using Type = std::decay_t<decltype(v)>;
-                            if constexpr (std::is_same_v<Type, std::string> || std::is_arithmetic_v<Type>) {
-                                gather.setValue(name, std::forward<decltype(v)>(v));
-                            }
-                            else {
-                                // Unhandled types are all array types - the prior call checking `size != 1` only allows
-                                // for scalars.
-                                throw eckit::Exception(
-                                    std::string("Unexpected type when accessing GRIB message metadata ") +
-                                        typeid(v).name(),
-                                    Here());
+                std::visit(
+                    [&](auto&& v) {
+                        using Type = std::decay_t<decltype(v)>;
+                        if constexpr (std::is_same_v<Type, std::string> || std::is_arithmetic_v<Type>) {
+                            gather.setValue(name, std::forward<decltype(v)>(v));
+                        }
+                        if constexpr (std::is_same_v<Type, std::vector<uint8_t>>) {
+                            static const char hex_digits[] = "0123456789abcdef";
+                            std::string out;
+                            out.resize(v.size() * 2);
+
+                            for (size_t i = 0; i < v.size(); i++) {
+                                uint8_t b      = v[i];
+                                out[2 * i]     = hex_digits[b >> 4];
+                                out[2 * i + 1] = hex_digits[b & 0x0F];
                             }
-                        },
-                        k.get());
-                }
+                            gather.setValue(name, out);
+                        }
+                        else {
+                            // Unhandled types are all array types - the prior call checking `size != 1` only allows
+                            // for scalars.
+                            throw eckit::Exception(
+                                std::string("Unexpected type when accessing GRIB message metadata ") + typeid(v).name(),
+                                Here());
+                        }
+                    },
+                    k.get());
                 break;
             }
         }

src/metkit/codes/api/CodesAPI.cc

@@ -15,6 +15,7 @@
 
 #include "eccodes.h"
 
+
 namespace std {
 template <>
 struct default_delete<codes_handle> {
@@ -87,6 +88,7 @@ class OwningCodesHandle : public CodesHandle {
     void forceSet(const std::string& key, Span<const double> value) override;
     void forceSet(const std::string& key, Span<const float> value) override;
     size_t size(const std::string& key) const override;
+    size_t length(const std::string& key) const override;
     CodesValue get(const std::string& key) const override;
     NativeType type(const std::string& key) const override;
     long getLong(const std::string& key) const override;
@@ -222,6 +224,12 @@ size_t OwningCodesHandle::size(const std::string& key) const {
     return size;
 }
 
+size_t OwningCodesHandle::length(const std::string& key) const {
+    size_t length;
+    throwOnError(codes_get_length(raw(), key.c_str(), &length), Here(), "CodesHandle::length(string)", key);
+    return length;
+}
+
 /// Get the value of the key
 CodesValue OwningCodesHandle::get(const std::string& key) const {
     NativeType ktype = type(key);
@@ -353,7 +361,7 @@ std::vector<std::string> OwningCodesHandle::getStringArray(const std::string& ke
 
 std::vector<uint8_t> OwningCodesHandle::getBytes(const std::string& key) const {
     std::vector<uint8_t> ret;
-    std::size_t ksize = size(key);
+    std::size_t ksize = length(key) / 2;
     ret.resize(ksize);
     throwOnError(codes_get_bytes(raw(), key.c_str(), ret.data(), &ksize), Here(), "CodesHandle::getBytes(string)", key);
     ret.resize(ksize);
@@ -506,7 +514,7 @@ class ConcreteKeyIterator : public KeyIterator {
     std::vector<uint8_t> getBytes() const override {
         std::vector<uint8_t> ret;
         std::string key  = name();
-        std::size_t size = refHandle_.get().size(key);
+        std::size_t size = refHandle_.get().length(key) / 2;
         ret.resize(size);
         throwOnError(codes_keys_iterator_get_bytes(it_.get(), ret.data(), &size), Here(), "KeyIterator::getBytes()");
         ret.resize(size);

src/metkit/codes/api/CodesAPI.h

@@ -199,6 +199,14 @@ class CodesHandle {
     /// @return For given scalars 1 is returned. For given arrays the size of the array is returned..
     virtual size_t size(const std::string& key) const = 0;
 
+    /// Returns the number of chars/bytes contained for a given key
+    //  of type string/byte array.
+    ///
+    /// Can be used to determine if a field is storing a scalar or an array.
+    /// @param key Name of the field that is supposed to be inspected.
+    /// @return Number of chars/bytes of contained string/byte array
+    virtual size_t length(const std::string& key) const = 0;
+
     /// Get the value of the key.
     ///
     /// High-level functionality: