mirror of https://github.com/ecmwf/eccodes.git
Modernisation: Remove unused file
This commit is contained in:
Eugen Betke
parent
859399da2c
commit
a8e68a4fd1
|
|
@ -1,877 +0,0 @@
|
|||
/*
|
||||
* (C) Copyright 2005- 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.
|
||||
*/
|
||||
|
||||
/***************************************************************************
|
||||
* Jean Baptiste Filippi - 01.11.2005
|
||||
***************************************************************************/
|
||||
|
||||
#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
|
||||
GRIB_INLINE static int grib_inline_strcmp(const char* a, const char* b)
|
||||
{
|
||||
if (*a != *b)
|
||||
return 1;
|
||||
while ((*a != 0 && *b != 0) && *(a) == *(b)) {
|
||||
a++;
|
||||
b++;
|
||||
}
|
||||
return (*a == 0 && *b == 0) ? 0 : 1;
|
||||
}
|
||||
|
||||
void grib_accessor_dump(grib_accessor* a, grib_dumper* f)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
if (c->dump) {
|
||||
c->dump(a, f);
|
||||
return;
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
}
|
||||
|
||||
int grib_pack_missing(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is packing (double) %g",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->pack_missing) {
|
||||
return c->pack_missing(a);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// int grib_pack_zero(grib_accessor* a)
|
||||
// {
|
||||
// grib_accessor_class* c = a->cclass;
|
||||
// while (c) {
|
||||
// if (c->clear) {
|
||||
// return c->clear(a);
|
||||
// }
|
||||
// c = c->super ? *(c->super) : NULL;
|
||||
// }
|
||||
// DEBUG_ASSERT(0);
|
||||
// return 0;
|
||||
// }
|
||||
|
||||
int grib_is_missing_internal(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
// grib_context_log(a->context, GRIB_LOG_DEBUG,
|
||||
// "(%s)%s is packing (double) %g",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->is_missing) {
|
||||
return c->is_missing(a);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_pack_double(grib_accessor* a, const double* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is packing (double) %g",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->pack_double) {
|
||||
return c->pack_double(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
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;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_pack_expression(grib_accessor* a, grib_expression* e)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
// grib_context_log(a->context, GRIB_LOG_INFO, "....(%s)%s is packing",
|
||||
// (a->parent->owner)?(a->parent->owner->name):"root",
|
||||
// a->name);
|
||||
while (c) {
|
||||
if (c->pack_expression) {
|
||||
return c->pack_expression(a, e);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_pack_string(grib_accessor* a, const char* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is packing (string) %s",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?v:"(null)");
|
||||
while (c) {
|
||||
if (c->pack_string) {
|
||||
return c->pack_string(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_pack_string_array(grib_accessor* a, const char** v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is packing (string) %s",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?v:"(null)");
|
||||
while (c) {
|
||||
if (c->pack_string_array) {
|
||||
return c->pack_string_array(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_pack_long(grib_accessor* a, const long* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is packing (long) %d",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->pack_long) {
|
||||
return c->pack_long(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_pack_bytes(grib_accessor* a, const unsigned char* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is packing (bytes) %d",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->pack_bytes) {
|
||||
return c->pack_bytes(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_unpack_bytes(grib_accessor* a, unsigned char* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is unpacking (bytes)",(a->parent->owner)?(a->parent->owner->name):"root", a->name);
|
||||
while (c) {
|
||||
if (c->unpack_bytes) {
|
||||
return c->unpack_bytes(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_unpack_double_subarray(grib_accessor* a, double* v, size_t start, size_t len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
if (c->unpack_double_subarray) {
|
||||
return c->unpack_double_subarray(a, v, start, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_unpack_double(grib_accessor* a, double* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is unpacking (double)",(a->parent->owner)?(a->parent->owner->name):"root", a->name);
|
||||
while (c) {
|
||||
if (c->unpack_double) {
|
||||
return c->unpack_double(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_unpack_float(grib_accessor* a, float* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
//printf("grib_accessor.c grib_unpack_float:: c->name=%s\n",c->name);
|
||||
if (c->unpack_float) {
|
||||
return c->unpack_float(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
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)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
if (c->unpack_double_element) {
|
||||
return c->unpack_double_element(a, i, v);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
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
|
||||
int grib_unpack_double_element_set(grib_accessor* a, const size_t* index_array, size_t len, double* val_array)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
DEBUG_ASSERT(len > 0);
|
||||
while (c) {
|
||||
if (c->unpack_double_element_set) {
|
||||
return c->unpack_double_element_set(a, index_array, len, val_array);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
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;
|
||||
// DEBUG_ASSERT(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)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is unpacking (string)",(a->parent->owner)?(a->parent->owner->name):"root", a->name );
|
||||
while (c) {
|
||||
if (c->unpack_string) {
|
||||
return c->unpack_string(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_unpack_string_array(grib_accessor* a, char** v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
if (c->unpack_string_array) {
|
||||
return c->unpack_string_array(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_accessors_list_unpack_long(grib_accessors_list* al, long* val, size_t* buffer_len)
|
||||
{
|
||||
int err = GRIB_SUCCESS;
|
||||
size_t unpacked_len = 0;
|
||||
size_t len = 0;
|
||||
|
||||
while (al && err == GRIB_SUCCESS) {
|
||||
len = *buffer_len - unpacked_len;
|
||||
err = grib_unpack_long(al->accessor, val + unpacked_len, &len);
|
||||
unpacked_len += len;
|
||||
al = al->next;
|
||||
}
|
||||
|
||||
*buffer_len = unpacked_len;
|
||||
return err;
|
||||
}
|
||||
|
||||
int grib_accessors_list_unpack_double(grib_accessors_list* al, double* val, size_t* buffer_len)
|
||||
{
|
||||
int err = GRIB_SUCCESS;
|
||||
size_t unpacked_len = 0;
|
||||
size_t len = 0;
|
||||
|
||||
while (al && err == GRIB_SUCCESS) {
|
||||
len = *buffer_len - unpacked_len;
|
||||
err = grib_unpack_double(al->accessor, val + unpacked_len, &len);
|
||||
unpacked_len += len;
|
||||
al = al->next;
|
||||
}
|
||||
|
||||
*buffer_len = unpacked_len;
|
||||
return err;
|
||||
}
|
||||
|
||||
int grib_accessors_list_unpack_float(grib_accessors_list* al, float* val, size_t* buffer_len)
|
||||
{
|
||||
int err = GRIB_SUCCESS;
|
||||
size_t unpacked_len = 0;
|
||||
size_t len = 0;
|
||||
|
||||
while (al && err == GRIB_SUCCESS) {
|
||||
len = *buffer_len - unpacked_len;
|
||||
err = grib_unpack_float(al->accessor, val + unpacked_len, &len);
|
||||
unpacked_len += len;
|
||||
al = al->next;
|
||||
}
|
||||
|
||||
*buffer_len = unpacked_len;
|
||||
return err;
|
||||
}
|
||||
|
||||
int grib_accessors_list_unpack_string(grib_accessors_list* al, char** val, size_t* buffer_len)
|
||||
{
|
||||
int err = GRIB_SUCCESS;
|
||||
size_t unpacked_len = 0;
|
||||
size_t len = 0;
|
||||
|
||||
while (al && err == GRIB_SUCCESS) {
|
||||
len = *buffer_len - unpacked_len;
|
||||
err = grib_unpack_string_array(al->accessor, val + unpacked_len, &len);
|
||||
unpacked_len += len;
|
||||
al = al->next;
|
||||
}
|
||||
|
||||
*buffer_len = unpacked_len;
|
||||
return err;
|
||||
}
|
||||
|
||||
int grib_unpack_long(grib_accessor* a, long* v, size_t* len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG, "(%s)%s is unpacking (long)",(a->parent->owner)?(a->parent->owner->name):"root", a->name );
|
||||
while (c) {
|
||||
if (c->unpack_long) {
|
||||
return c->unpack_long(a, v, len);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long grib_accessor_get_native_type(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = NULL;
|
||||
if (a)
|
||||
c = a->cclass;
|
||||
|
||||
while (c) {
|
||||
if (c->get_native_type)
|
||||
return c->get_native_type(a);
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long grib_get_next_position_offset(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = NULL;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG,
|
||||
// "(%s)%s is checking next (long)",(a->parent->owner)?(a->parent->owner->name):"root", a->name );
|
||||
if (a)
|
||||
c = a->cclass;
|
||||
|
||||
while (c) {
|
||||
if (c->next_offset)
|
||||
return c->next_offset(a);
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long grib_string_length(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = NULL;
|
||||
if (a)
|
||||
c = a->cclass;
|
||||
|
||||
while (c) {
|
||||
if (c->string_length)
|
||||
return c->string_length(a);
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long grib_byte_offset(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = NULL;
|
||||
if (a)
|
||||
c = a->cclass;
|
||||
|
||||
while (c) {
|
||||
if (c->byte_offset)
|
||||
return c->byte_offset(a);
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
long grib_byte_count(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = NULL;
|
||||
if (a)
|
||||
c = a->cclass;
|
||||
|
||||
while (c) {
|
||||
if (c->byte_count)
|
||||
return c->byte_count(a);
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_value_count(grib_accessor* a, long* count)
|
||||
{
|
||||
grib_accessor_class* c = NULL;
|
||||
int err = 0;
|
||||
if (a)
|
||||
c = a->cclass;
|
||||
|
||||
while (c) {
|
||||
if (c->value_count) {
|
||||
err = c->value_count(a, count);
|
||||
return err;
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_accessors_list_value_count(grib_accessors_list* al, size_t* count)
|
||||
{
|
||||
long lcount = 0;
|
||||
*count = 0;
|
||||
while (al) {
|
||||
grib_value_count(al->accessor, &lcount);
|
||||
*count += lcount;
|
||||
al = al->next;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int grib_accessor_notify_change(grib_accessor* a, grib_accessor* changed)
|
||||
{
|
||||
grib_accessor_class* c = NULL;
|
||||
if (a)
|
||||
c = a->cclass;
|
||||
|
||||
while (c) {
|
||||
if (c->notify_change)
|
||||
return c->notify_change(a, changed);
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
if (a && a->cclass)
|
||||
fprintf(stderr, "Error: notify_change not implemented for %s %s\n", a->cclass->name, a->name);
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// For this one, ALL init are called
|
||||
static void init_accessor(grib_accessor_class* c, grib_accessor* a, const long len, grib_arguments* args)
|
||||
{
|
||||
if (c) {
|
||||
grib_accessor_class* s = c->super ? *(c->super) : NULL;
|
||||
init_accessor(s, a, len, args);
|
||||
if (c->init)
|
||||
c->init(a, len, args);
|
||||
}
|
||||
}
|
||||
|
||||
void grib_init_accessor(grib_accessor* a, const long len, grib_arguments* args)
|
||||
{
|
||||
init_accessor(a->cclass, a, len, args);
|
||||
}
|
||||
|
||||
// For this one, ALL destroy are called
|
||||
void grib_accessor_delete(grib_context* ct, grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
grib_accessor_class* s = c->super ? *(c->super) : NULL;
|
||||
//printf("grib_accessor_delete: before destroy a=%p c->name=%s ==> a->name=%s\n", (void*)a, c->name, a->name);
|
||||
if (c->destroy) {
|
||||
c->destroy(ct, a);
|
||||
}
|
||||
c = s;
|
||||
}
|
||||
// printf("grib_accessor_delete before free a=%p\n", (void*)a);
|
||||
grib_context_free(ct, a);
|
||||
}
|
||||
|
||||
grib_accessor* grib_accessor_clone(grib_accessor* a, grib_section* s, int* err)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
const grib_context* ct = a->context;
|
||||
while (c) {
|
||||
grib_accessor_class* super = c->super ? *(c->super) : NULL;
|
||||
grib_context_log(ct, GRIB_LOG_DEBUG, "clone %s ==> %s", c->name, a->name);
|
||||
if (c->make_clone) {
|
||||
return c->make_clone(a, s, err);
|
||||
}
|
||||
c = super;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void grib_update_size(grib_accessor* a, size_t len)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG,
|
||||
// "(%s)%s is packing (double) %g",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->update_size) {
|
||||
c->update_size(a, len);
|
||||
return;
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
}
|
||||
|
||||
int grib_nearest_smaller_value(grib_accessor* a, double val, double* nearest)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
if (c->nearest_smaller_value) {
|
||||
return c->nearest_smaller_value(a, val, nearest);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
size_t grib_preferred_size(grib_accessor* a, int from_handle)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
// grib_context_log(a->context, GRIB_LOG_DEBUG,
|
||||
// "(%s)%s is packing (long) %d",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->preferred_size) {
|
||||
return c->preferred_size(a, from_handle);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
grib_accessor* grib_next_accessor(grib_accessor* a)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
while (c) {
|
||||
if (c->next) {
|
||||
return c->next(a, 1);
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void grib_resize(grib_accessor* a, size_t new_size)
|
||||
{
|
||||
grib_accessor_class* c = a->cclass;
|
||||
//grib_context_log(a->context, GRIB_LOG_DEBUG,
|
||||
// "(%s)%s is packing (long) %d",(a->parent->owner)?(a->parent->owner->name):"root", a->name ,v?(*v):0);
|
||||
while (c) {
|
||||
if (c->resize) {
|
||||
c->resize(a, new_size);
|
||||
return;
|
||||
}
|
||||
c = c->super ? *(c->super) : NULL;
|
||||
}
|
||||
DEBUG_ASSERT(0);
|
||||
return;
|
||||
}
|
||||
|
||||
int grib_compare_accessors(grib_accessor* a1, grib_accessor* a2, int compare_flags)
|
||||
{
|
||||
int ret = 0;
|
||||
long type1 = 0;
|
||||
long type2 = 0;
|
||||
int type_mismatch = 0;
|
||||
grib_accessor_class* c1 = NULL;
|
||||
|
||||
if ((compare_flags & GRIB_COMPARE_NAMES) && grib_inline_strcmp(a1->name, a2->name))
|
||||
return GRIB_NAME_MISMATCH;
|
||||
|
||||
if (compare_flags & GRIB_COMPARE_TYPES) {
|
||||
type1 = grib_accessor_get_native_type(a1);
|
||||
type2 = grib_accessor_get_native_type(a2);
|
||||
|
||||
type_mismatch = type1 != type2 ? 1 : 0;
|
||||
}
|
||||
|
||||
ret = GRIB_UNABLE_TO_COMPARE_ACCESSORS;
|
||||
c1 = a1->cclass;
|
||||
while (c1) {
|
||||
if (c1->compare) {
|
||||
ret = c1->compare(a1, a2);
|
||||
break;
|
||||
}
|
||||
c1 = c1->super ? *(c1->super) : NULL;
|
||||
}
|
||||
|
||||
if (ret == GRIB_VALUE_MISMATCH && type_mismatch)
|
||||
ret = GRIB_TYPE_AND_VALUE_MISMATCH;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// int grib_accessor_clear_attributes(grib_accessor* a)
|
||||
// {
|
||||
// int id;
|
||||
// for (id=0;id<MAX_ACCESSOR_ATTRIBUTES;id++) {
|
||||
// a->attributes[id]=NULL;
|
||||
// }
|
||||
// return 0;
|
||||
// }
|
||||
|
||||
int grib_accessor_add_attribute(grib_accessor* a, grib_accessor* attr, int nest_if_clash)
|
||||
{
|
||||
int id = 0;
|
||||
int idx = 0;
|
||||
grib_accessor* same = NULL;
|
||||
grib_accessor* aloc = a;
|
||||
|
||||
if (grib_accessor_has_attributes(a)) {
|
||||
same = grib_accessor_get_attribute_index(a, attr->name, &id);
|
||||
}
|
||||
|
||||
if (same) {
|
||||
if (nest_if_clash == 0)
|
||||
return GRIB_ATTRIBUTE_CLASH;
|
||||
aloc = same;
|
||||
}
|
||||
|
||||
for (id = 0; id < MAX_ACCESSOR_ATTRIBUTES; id++) {
|
||||
if (aloc->attributes[id] == NULL) {
|
||||
// attr->parent=a->parent;
|
||||
aloc->attributes[id] = attr;
|
||||
attr->parent_as_attribute = aloc;
|
||||
if (aloc->same)
|
||||
attr->same = grib_accessor_get_attribute_index(aloc->same, attr->name, &idx);
|
||||
|
||||
grib_context_log(a->context, GRIB_LOG_DEBUG, "added attribute %s->%s", a->name, attr->name);
|
||||
return GRIB_SUCCESS;
|
||||
}
|
||||
}
|
||||
return GRIB_TOO_MANY_ATTRIBUTES;
|
||||
}
|
||||
|
||||
// int grib_accessor_replace_attribute(grib_accessor* a, grib_accessor* attr)
|
||||
// {
|
||||
// int id = 0;
|
||||
// int idx = 0;
|
||||
// if (grib_accessor_get_attribute_index(a, attr->name, &id) != NULL) {
|
||||
// grib_accessor_delete(a->context, a->attributes[id]);
|
||||
// a->attributes[id] = attr;
|
||||
// attr->parent_as_attribute = a;
|
||||
// if (a->same)
|
||||
// attr->same = grib_accessor_get_attribute_index(a->same, attr->name, &idx);
|
||||
// }
|
||||
// else {
|
||||
// grib_accessor_add_attribute(a, attr, 0);
|
||||
// }
|
||||
// return GRIB_SUCCESS;
|
||||
// }
|
||||
|
||||
// int grib_accessor_delete_attribute(grib_accessor* a, const char* name)
|
||||
// {
|
||||
// int id = 0;
|
||||
// if (grib_accessor_get_attribute_index(a, name, &id) != NULL) {
|
||||
// grib_accessor_delete(a->context, a->attributes[id]);
|
||||
// a->attributes[id] = NULL;
|
||||
// return GRIB_SUCCESS;
|
||||
// }
|
||||
// else {
|
||||
// return GRIB_NOT_FOUND;
|
||||
// }
|
||||
// }
|
||||
|
||||
// grib_accessor* grib_accessor_get_attribute_by_index(grib_accessor* a, int index)
|
||||
// {
|
||||
// if (index < MAX_ACCESSOR_ATTRIBUTES)
|
||||
// return a->attributes[index];
|
||||
// return NULL;
|
||||
// }
|
||||
|
||||
// const char* grib_accessor_get_name(grib_accessor* a)
|
||||
// {
|
||||
// return a->name;
|
||||
// }
|
||||
|
||||
grib_accessor* grib_accessor_get_attribute_index(grib_accessor* a, const char* name, int* index)
|
||||
{
|
||||
int i = 0;
|
||||
while (i < MAX_ACCESSOR_ATTRIBUTES && a->attributes[i]) {
|
||||
if (!grib_inline_strcmp(a->attributes[i]->name, name)) {
|
||||
*index = i;
|
||||
return a->attributes[i];
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int grib_accessor_has_attributes(grib_accessor* a)
|
||||
{
|
||||
return a->attributes[0] ? 1 : 0;
|
||||
}
|
||||
|
||||
grib_accessor* grib_accessor_get_attribute(grib_accessor* a, const char* name)
|
||||
{
|
||||
int index = 0;
|
||||
const char* p = 0;
|
||||
char* basename = NULL;
|
||||
const char* attribute_name = NULL;
|
||||
grib_accessor* acc = NULL;
|
||||
p = name;
|
||||
while (*(p + 1) != '\0' && (*p != '-' || *(p + 1) != '>'))
|
||||
p++;
|
||||
if (*(p + 1) == '\0') {
|
||||
return grib_accessor_get_attribute_index(a, name, &index);
|
||||
}
|
||||
else {
|
||||
size_t size = p - name;
|
||||
attribute_name = p + 2;
|
||||
basename = (char*)grib_context_malloc_clear(a->context, size + 1);
|
||||
basename = (char*)memcpy(basename, name, size);
|
||||
acc = grib_accessor_get_attribute_index(a, basename, &index);
|
||||
grib_context_free(a->context, basename);
|
||||
if (acc)
|
||||
return grib_accessor_get_attribute(acc, attribute_name);
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
grib_accessors_list* grib_accessors_list_create(grib_context* c)
|
||||
{
|
||||
return (grib_accessors_list*)grib_context_malloc_clear(c, sizeof(grib_accessors_list));
|
||||
}
|
||||
|
||||
void grib_accessors_list_push(grib_accessors_list* al, grib_accessor* a, int rank)
|
||||
{
|
||||
grib_accessors_list* last;
|
||||
const grib_context* c = a->context;
|
||||
|
||||
last = grib_accessors_list_last(al);
|
||||
if (last && last->accessor) {
|
||||
last->next = (grib_accessors_list*)grib_context_malloc_clear(c, sizeof(grib_accessors_list));
|
||||
last->next->accessor = a;
|
||||
last->next->prev = last;
|
||||
last->next->rank = rank;
|
||||
al->last = last->next;
|
||||
}
|
||||
else {
|
||||
al->accessor = a;
|
||||
al->rank = rank;
|
||||
al->last = al;
|
||||
}
|
||||
}
|
||||
|
||||
grib_accessors_list* grib_accessors_list_last(grib_accessors_list* al)
|
||||
{
|
||||
// grib_accessors_list* last=al;
|
||||
// grib_accessors_list* next=al->next;
|
||||
// while(next) {
|
||||
// last=next;
|
||||
// next=last->next;
|
||||
// }
|
||||
return al->last;
|
||||
}
|
||||
|
||||
// grib_accessors_list* grib_accessors_list_find(grib_accessors_list* al, const grib_accessor* a)
|
||||
// {
|
||||
// grib_accessors_list* last = al;
|
||||
// grib_accessors_list* next = al->next;
|
||||
// while (next) {
|
||||
// if (last->accessor == a)
|
||||
// return last;
|
||||
// last = next;
|
||||
// next = last->next;
|
||||
// }
|
||||
// return NULL;
|
||||
// }
|
||||
|
||||
void grib_accessors_list_delete(grib_context* c, grib_accessors_list* al)
|
||||
{
|
||||
grib_accessors_list* tmp;
|
||||
|
||||
while (al) {
|
||||
tmp = al->next;
|
||||
//grib_accessor_delete(c, al->accessor);
|
||||
grib_context_free(c, al);
|
||||
al = tmp;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue