ECC-1467: GRIB: Support data values array decoded as floats (Part 02)

src/eccodes.c

@@ -361,6 +361,10 @@ int codes_get_double_array(const grib_handle* h, const char* key, double* vals,
 {
     return grib_get_double_array(h, key, vals, length);
 }
+int codes_get_float_array(const grib_handle* h, const char* key, float* vals, size_t* length)
+{
+    return grib_get_float_array(h, key, vals, length);
+}
 int codes_get_long_array(const grib_handle* h, const char* key, long* vals, size_t* length)
 {
     return grib_get_long_array(h, key, vals, length);

src/eccodes.h

@@ -844,6 +844,7 @@ int codes_get_bytes(const codes_handle* h, const char* key, unsigned char* bytes
 * @return         0 if OK, integer value on error
 */
 int codes_get_double_array(const codes_handle* h, const char* key, double* vals, size_t* length);
+int codes_get_float_array(const codes_handle* h, const char* key, float* vals, size_t* length);
 
 /**
 *  Get long array values from a key. If several keys of the same name are present, the last one is returned

src/eccodes_prototypes.h

@@ -115,6 +115,7 @@ int grib_pack_missing(grib_accessor* a);
 int grib_pack_zero(grib_accessor* a);
 int grib_is_missing_internal(grib_accessor* a);
 int grib_pack_double(grib_accessor* a, const double* v, size_t* len);
+int grib_pack_float(grib_accessor* a, const float* v, size_t* len);
 int grib_pack_expression(grib_accessor* a, grib_expression* e);
 int grib_pack_string(grib_accessor* a, const char* v, size_t* len);
 int grib_pack_string_array(grib_accessor* a, const char** v, size_t* len);
@@ -123,8 +124,11 @@ int grib_pack_bytes(grib_accessor* a, const unsigned char* v, size_t* len);
 int grib_unpack_bytes(grib_accessor* a, unsigned char* v, size_t* len);
 int grib_unpack_double_subarray(grib_accessor* a, double* v, size_t start, size_t len);
 int grib_unpack_double(grib_accessor* a, double* v, size_t* len);
+int grib_unpack_float(grib_accessor* a, float* v, size_t* len);
 int grib_unpack_double_element(grib_accessor* a, size_t i, double* v);
 int grib_unpack_double_element_set(grib_accessor* a, const size_t* index_array, size_t len, double* val_array);
+int grib_unpack_float_element(grib_accessor* a, size_t i, float* v);
+int grib_unpack_float_element_set(grib_accessor* a, const size_t* index_array, size_t len, float* val_array);
 int grib_unpack_string(grib_accessor* a, char* v, size_t* len);
 int grib_unpack_string_array(grib_accessor* a, char** v, size_t* len);
 int grib_accessors_list_unpack_long(grib_accessors_list* al, long* val, size_t* buffer_len);
@@ -1250,8 +1254,12 @@ int grib_get_bytes(const grib_handle* h, const char* name, unsigned char* val, s
 int grib_get_native_type(const grib_handle* h, const char* name, int* type);
 const char* grib_get_accessor_class_name(grib_handle* h, const char* name);
 int ecc__grib_get_double_array_internal(const grib_handle* h, grib_accessor* a, double* val, size_t buffer_len, size_t* decoded_length);
+
 int grib_get_double_array_internal(const grib_handle* h, const char* name, double* val, size_t* length);
 int grib_get_double_array(const grib_handle* h, const char* name, double* val, size_t* length);
+int grib_get_float_array_internal(const grib_handle* h, const char* name, float* val, size_t* length);
+int grib_get_float_array(const grib_handle* h, const char* name, float* val, size_t* length);
+
 int ecc__grib_get_string_length(grib_accessor* a, size_t* size);
 int grib_get_string_length(const grib_handle* h, const char* name, size_t* size);
 int ecc__grib_get_size(const grib_handle* h, grib_accessor* a, size_t* size);

src/grib_accessor.c

@@ -98,6 +98,19 @@ int grib_pack_double(grib_accessor* a, const double* v, size_t* len)
     return 0;
 }
 
+int grib_pack_float(grib_accessor* a, const float* v, size_t* len)
+{
+    grib_accessor_class* c = a->cclass;
+    while (c) {
+        if (c->pack_float) {
+            return c->pack_float(a, v, len);
+        }
+        c = c->super ? *(c->super) : NULL;
+    }
+    DebugAssert(0);
+    return 0;
+}
+
 int grib_pack_expression(grib_accessor* a, grib_expression* e)
 {
     grib_accessor_class* c = a->cclass;
@@ -209,6 +222,19 @@ int grib_unpack_double(grib_accessor* a, double* v, size_t* len)
     return 0;
 }
 
+int grib_unpack_float(grib_accessor* a, float* v, size_t* len)
+{
+    grib_accessor_class* c = a->cclass;
+    while (c) {
+        if (c->unpack_float) {
+            return c->unpack_float(a, v, len);
+        }
+        c = c->super ? *(c->super) : NULL;
+    }
+    DebugAssert(0);
+    return GRIB_NOT_IMPLEMENTED;
+}
+
 int grib_unpack_double_element(grib_accessor* a, size_t i, double* v)
 {
     grib_accessor_class* c = a->cclass;
@@ -220,6 +246,18 @@ int grib_unpack_double_element(grib_accessor* a, size_t i, double* v)
     }
     return GRIB_NOT_IMPLEMENTED;
 }
+int grib_unpack_float_element(grib_accessor* a, size_t i, float* v)
+{
+    /* grib_accessor_class* c = a->cclass;
+    * while (c) {
+    *     if (c->unpack_float_element) {
+    *         return c->unpack_float_element(a, i, v);
+    *     }
+    *     c = c->super ? *(c->super) : NULL;
+    * }
+    */
+    return GRIB_NOT_IMPLEMENTED;
+}
 
 /* Get the values for the indices passed in.
  * The length of the 'index_array' argument should be 'len' and 'val_array' should also contain at least 'len' elements
@@ -236,6 +274,20 @@ int grib_unpack_double_element_set(grib_accessor* a, const size_t* index_array,
     }
     return GRIB_NOT_IMPLEMENTED;
 }
+int grib_unpack_float_element_set(grib_accessor* a, const size_t* index_array, size_t len, float* val_array)
+{
+    /*
+    *grib_accessor_class* c = a->cclass;
+    *DebugAssert(len > 0);
+    *while (c) {
+    *    if (c->unpack_float_element_set) {
+    *        return c->unpack_float_element_set(a, index_array, len, val_array);
+    *    }
+    *    c = c->super ? *(c->super) : NULL;
+    *}
+    */
+   return GRIB_NOT_IMPLEMENTED;
+}
 
 int grib_unpack_string(grib_accessor* a, char* v, size_t* len)
 {

src/grib_accessor_class_gen.c

@@ -21,6 +21,7 @@
    CLASS      = accessor
    IMPLEMENTS = unpack_long;pack_long; clear
    IMPLEMENTS = unpack_double;pack_double;unpack_double_element;unpack_double_element_set
+   IMPLEMENTS = unpack_float
    IMPLEMENTS = unpack_string;pack_string
    IMPLEMENTS = unpack_string_array;pack_string_array
    IMPLEMENTS = unpack_bytes;pack_bytes
@@ -56,6 +57,7 @@ static int pack_string_array(grib_accessor*, const char**, size_t* len);
 static int pack_expression(grib_accessor*, grib_expression*);
 static int unpack_bytes(grib_accessor*, unsigned char*, size_t* len);
 static int unpack_double(grib_accessor*, double* val, size_t* len);
+static int unpack_float(grib_accessor*, float* val, size_t* len);
 static int unpack_long(grib_accessor*, long* val, size_t* len);
 static int unpack_string(grib_accessor*, char*, size_t* len);
 static int unpack_string_array(grib_accessor*, char**, size_t* len);
@@ -110,7 +112,7 @@ static grib_accessor_class _grib_accessor_class_gen = {
     &pack_double,                /* grib_pack procedures double */
     0,                 /* grib_pack procedures float */
     &unpack_double,              /* grib_unpack procedures double */
-    0,               /* grib_unpack procedures float */
+    &unpack_float,               /* grib_unpack procedures float */
     &pack_string,                /* grib_pack procedures string */
     &unpack_string,              /* grib_unpack procedures string */
     &pack_string_array,          /* grib_pack array procedures string */
@@ -339,6 +341,29 @@ static int unpack_double(grib_accessor* a, double* v, size_t* len)
     return GRIB_NOT_IMPLEMENTED;
 }
 
+static int unpack_float(grib_accessor* a, float* v, size_t* len)
+{
+    int type = GRIB_TYPE_UNDEFINED;
+    printf("====%s\n",a->name);
+    printf("DEBUG unpack_float::  a->cclass->unpack_double=%p\n", (void*)a->cclass->unpack_double);
+    printf("DEBUG unpack_float::            &unpack_double=%p\n", (void*)&unpack_double);
+    if (a->cclass->unpack_double && a->cclass->unpack_double != &unpack_double) {
+        double val = 0.0;
+        size_t l = 1;
+        grib_unpack_double(a, &val, &l);
+        *v = val;
+        grib_context_log(a->context, GRIB_LOG_DEBUG, "Casting double %s to float", a->name);
+        return GRIB_SUCCESS;
+    }
+
+    grib_context_log(a->context, GRIB_LOG_ERROR, "Cannot unpack %s as float", a->name);
+    if (grib_get_native_type(grib_handle_of_accessor(a), a->name, &type) == GRIB_SUCCESS) {
+        grib_context_log(a->context, GRIB_LOG_ERROR, "Hint: Try unpacking as %s", grib_get_type_name(type));
+    }
+
+    return GRIB_NOT_IMPLEMENTED;
+}
+
 static int unpack_string(grib_accessor* a, char* v, size_t* len)
 {
     if (a->cclass->unpack_double && a->cclass->unpack_double != &unpack_double) {

src/grib_api.h

@@ -859,6 +859,7 @@ int grib_get_bytes(const grib_handle* h, const char* key, unsigned char* bytes,
 * @return            0 if OK, integer value on error
 */
 int grib_get_double_array(const grib_handle* h, const char* key, double* vals, size_t* length);
+int grib_get_float_array(const grib_handle* h, const char* key, float* vals, size_t* length);
 
 /**
 *  Get long array values from a key. If several keys of the same name are present, the last one is returned

src/grib_value.c

@@ -1248,6 +1248,24 @@ int _grib_get_double_array_internal(const grib_handle* h, grib_accessor* a, doub
     }
 }
 
+int _grib_get_float_array_internal(const grib_handle* h, grib_accessor* a, float* val, size_t buffer_len, size_t* decoded_length)
+{
+    if (a) {
+        int err = _grib_get_float_array_internal(h, a->same, val, buffer_len, decoded_length);
+
+        if (err == GRIB_SUCCESS) {
+            size_t len = buffer_len - *decoded_length;
+            err        = grib_unpack_float(a, val + *decoded_length, &len);
+            *decoded_length += len;
+        }
+
+        return err;
+    }
+    else {
+        return GRIB_SUCCESS;
+    }
+}
+
 int grib_get_double_array_internal(const grib_handle* h, const char* name, double* val, size_t* length)
 {
     int ret = grib_get_double_array(h, name, val, length);
@@ -1259,6 +1277,17 @@ int grib_get_double_array_internal(const grib_handle* h, const char* name, doubl
 
     return ret;
 }
+int grib_get_float_array_internal(const grib_handle* h, const char* name, float* val, size_t* length)
+{
+    int ret = grib_get_float_array(h, name, val, length);
+
+    if (ret != GRIB_SUCCESS)
+        grib_context_log(h->context, GRIB_LOG_ERROR,
+                         "unable to get %s as float array (%s)",
+                         name, grib_get_error_message(ret));
+
+    return ret;
+}
 
 int grib_get_double_array(const grib_handle* h, const char* name, double* val, size_t* length)
 {
@@ -1289,6 +1318,19 @@ int grib_get_double_array(const grib_handle* h, const char* name, double* val, s
     }
 }
 
+int grib_get_float_array(const grib_handle* h, const char* name, float* val, size_t *length)
+{
+    size_t len = *length;
+    grib_accessor* a = grib_find_accessor(h, name);
+    if(!a) return GRIB_NOT_FOUND;
+
+    /* TODO: For now only GRIB supported... no BUFR keys */
+    Assert(name[0]!='/');
+    Assert(name[0]!='#');
+    *length = 0;
+    return _grib_get_float_array_internal(h,a,val,len,length);
+}
+
 int ecc__grib_get_string_length(grib_accessor* a, size_t* size)
 {
     size_t s = 0;