ECC-1467: Simplification of templates

src/grib_accessor.cc

@@ -14,7 +14,7 @@
  *                                                                         *
  ***************************************************************************/
 
-#include "grib_api_internal.h"
+#include "grib_accessor.h"
 
 /* Note: A fast cut-down version of strcmp which does NOT return -1 */
 /* 0 means input strings are equal and 1 means not equal */
@@ -233,7 +233,19 @@ int grib_unpack_float(grib_accessor* a, float* v, size_t* len)
         c = c->super ? *(c->super) : NULL;
     }
     DebugAssert(0);
-    return GRIB_NOT_IMPLEMENTED;
+    return 0;
+}
+
+template <> 
+int grib_unpack<double>(grib_accessor* a, double* v, size_t* len) 
+{
+    return grib_unpack_double(a, v, len);
+}
+
+template <> 
+int grib_unpack<float>(grib_accessor* a, float* v, size_t* len) 
+{
+    return grib_unpack_float(a, v, len);
 }
 
 int grib_unpack_double_element(grib_accessor* a, size_t i, double* v)

src/grib_accessor_class_bitmap.cc

@@ -40,8 +40,8 @@ or edit "accessor.class" and rerun ./make_class.pl
 
 */
 
-//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_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 long next_offset(grib_accessor*);
@@ -89,8 +89,8 @@ static grib_accessor_class _grib_accessor_class_bitmap = {
     &unpack_long,                /* grib_unpack procedures long */
     0,                /* grib_pack procedures double */
     0,                 /* grib_pack procedures float */
-    &GribAccessorClassBitmap<double>::unpack,              /* grib_unpack procedures double */
-    &GribAccessorClassBitmap<float>::unpack,              /* grib_unpack procedures float */
+    &unpack_double,              /* grib_unpack procedures double */
+    &unpack_float,               /* grib_unpack procedures float */
     0,                /* grib_pack procedures string */
     &unpack_string,              /* grib_unpack procedures string */
     0,          /* grib_pack array procedures string */
@@ -247,6 +247,43 @@ static int unpack_long(grib_accessor* a, long* val, size_t* len)
     return GRIB_SUCCESS;
 }
 
+template <typename T>
+int unpack(grib_accessor* a, T* val, size_t* len)
+{
+    static_assert(std::is_floating_point<T>::value, "Requires floating points numbers");
+    long pos = a->offset * 8;
+    long tlen;
+    long i;
+    int err           = 0;
+    grib_handle* hand = grib_handle_of_accessor(a);
+
+    err = grib_value_count(a, &tlen);
+    if (err)
+        return err;
+
+    if (*len < tlen) {
+        grib_context_log(a->context, GRIB_LOG_ERROR, "Wrong size for %s it contains %ld values", a->name, tlen);
+        *len = 0;
+        return GRIB_ARRAY_TOO_SMALL;
+    }
+
+    for (i = 0; i < tlen; i++) {
+        val[i] = (T)grib_decode_unsigned_long(hand->buffer->data, &pos, 1);
+    }
+    *len = tlen;
+    return GRIB_SUCCESS;
+}
+
+static int unpack_double(grib_accessor* a, double* val, size_t* len)
+{
+    return unpack<double>(a, val, len);
+}
+
+static int unpack_float(grib_accessor* a, float* val, size_t* len)
+{
+    return unpack<float>(a, val, len);
+}
+
 static int unpack_double_element(grib_accessor* a, size_t idx, double* val)
 {
     long pos = a->offset * 8;

src/grib_accessor_class_data_apply_bitmap.cc

@@ -8,8 +8,9 @@
  * virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
  */
 
-#include "grib_api_internal.h"
-#include "grib_accessor_class_data_apply_bitmap.h"
+#include "grib_api_internal_cpp.h"
+#include <typeinfo>
+#include <type_traits>
 
 /*
    This is used by make_class.pl
@@ -44,13 +45,28 @@ or edit "accessor.class" and rerun ./make_class.pl
 
 static int get_native_type(grib_accessor*);
 static int pack_double(grib_accessor*, const double* val, size_t* len);
+template <typename T> static int unpack(grib_accessor* a, T* val, 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 value_count(grib_accessor*, long*);
 static void dump(grib_accessor*, grib_dumper*);
 static void init(grib_accessor*, const long, grib_arguments*);
 static void init_class(grib_accessor_class*);
 static int unpack_double_element(grib_accessor*, size_t i, double* val);
 static int unpack_double_element_set(grib_accessor*, const size_t* index_array, size_t len, double* val_array);
 
+typedef struct grib_accessor_data_apply_bitmap
+{
+    grib_accessor att;
+    /* Members defined in gen */
+    /* Members defined in data_apply_bitmap */
+    const char*  coded_values;
+    const char*  bitmap;
+    const char*  missing_value;
+    const char*  number_of_data_points;
+    const char*  number_of_values;
+    const char*  binary_scale_factor;
+} grib_accessor_data_apply_bitmap;
 
 extern grib_accessor_class* grib_accessor_class_gen;
 
@@ -77,8 +93,8 @@ static grib_accessor_class _grib_accessor_class_data_apply_bitmap = {
     0,                /* grib_unpack procedures long */
     &pack_double,                /* grib_pack procedures double */
     0,                 /* grib_pack procedures float */
-    &GribAccessorDataApplyBitmap<double>::unpack,              /* grib_unpack procedures double */
-    &GribAccessorDataApplyBitmap<float>::unpack,               /* grib_unpack procedures float */
+    &unpack_double,              /* grib_unpack procedures double */
+    &unpack_float,               /* grib_unpack procedures float */
     0,                /* grib_pack procedures string */
     0,              /* grib_unpack procedures string */
     0,          /* grib_pack array procedures string */
@@ -363,6 +379,99 @@ static int pack_double(grib_accessor* a, const double* val, size_t* len)
     return err;
 }
 
+template <typename T>
+static int unpack(grib_accessor* a, T* val, size_t* len)
+{
+    static_assert(std::is_floating_point<T>::value, "Requires floating point numbers");
+    grib_accessor_data_apply_bitmap* self = (grib_accessor_data_apply_bitmap*)a;
+
+    size_t i             = 0;
+    size_t j             = 0;
+    size_t n_vals        = 0;
+    long nn              = 0;
+    int err              = 0;
+    size_t coded_n_vals  = 0;
+    T* coded_vals   = NULL;
+    double missing_value = 0;
+
+    err    = grib_value_count(a, &nn);
+    n_vals = nn;
+    if (err)
+        return err;
+
+    if (!grib_find_accessor(grib_handle_of_accessor(a), self->bitmap))
+        return grib_get_array<T>(grib_handle_of_accessor(a), self->coded_values, val, len);
+
+    if ((err = grib_get_size(grib_handle_of_accessor(a), self->coded_values, &coded_n_vals)) != GRIB_SUCCESS)
+        return err;
+
+    if ((err = grib_get_double_internal(grib_handle_of_accessor(a), self->missing_value, &missing_value)) != GRIB_SUCCESS)
+        return err;
+
+    if (*len < n_vals) {
+        *len = n_vals;
+        return GRIB_ARRAY_TOO_SMALL;
+    }
+
+    if (coded_n_vals == 0) {
+        for (i = 0; i < n_vals; i++)
+            val[i] = missing_value;
+
+        *len = n_vals;
+        return GRIB_SUCCESS;
+    }
+
+    if ((err = grib_get_array_internal<T>(grib_handle_of_accessor(a), self->bitmap, val, &n_vals)) != GRIB_SUCCESS)
+        return err;
+
+    coded_vals = (T*)grib_context_malloc(a->context, coded_n_vals * sizeof(T));
+    if (coded_vals == NULL)
+        return GRIB_OUT_OF_MEMORY;
+
+    if ((err = grib_get_array<T>(grib_handle_of_accessor(a), self->coded_values, coded_vals, &coded_n_vals)) != GRIB_SUCCESS) {
+        grib_context_free(a->context, coded_vals);
+        return err;
+    }
+
+    grib_context_log(a->context, GRIB_LOG_DEBUG,
+                     "grib_accessor_class_data_apply_bitmap: %s : creating %s, %d values",
+                     __PRETTY_FUNCTION__,
+                     a->name, n_vals);
+
+    for (i = 0; i < n_vals; i++) {
+        if (val[i] == 0) {
+            val[i] = missing_value;
+        }
+        else {
+            val[i] = coded_vals[j++];
+            if (j > coded_n_vals) {
+                grib_context_free(a->context, coded_vals);
+                grib_context_log(a->context, GRIB_LOG_ERROR,
+                                 "grib_accessor_class_data_apply_bitmap [%s]:"
+                                 " %s :  number of coded values does not match bitmap %ld %ld",
+                                 a->name, __PRETTY_FUNCTION__, coded_n_vals, n_vals);
+
+                return GRIB_ARRAY_TOO_SMALL;
+            }
+        }
+    }
+
+    *len = n_vals;
+
+    grib_context_free(a->context, coded_vals);
+    return err;
+}
+
+static int unpack_double(grib_accessor* a, double* val, size_t* len)
+{
+    return unpack<double>(a, val, len);
+}
+
+static int unpack_float(grib_accessor* a, float* val, size_t* len)
+{
+    return unpack<float>(a, val, len);
+}
+
 static int get_native_type(grib_accessor* a)
 {
     /*  grib_accessor_data_apply_bitmap* self =  (grib_accessor_data_apply_bitmap*)a;