core
/
eccodes
mirror of https://github.com/ecmwf/eccodes.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
eccodes/python3/grib_interface.c

2474 lines
59 KiB
C
Raw Blame History

/*
* (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.
*/
#include "grib_api_internal.h"
#include "assert.h"
#if HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#if HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif
#include <ctype.h>
#include <errno.h>
#if GRIB_PTHREADS
static pthread_once_t once = PTHREAD_ONCE_INIT;
static pthread_mutex_t handle_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t index_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t multi_handle_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t iterator_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t keys_iterator_mutex = PTHREAD_MUTEX_INITIALIZER;
static void init() {
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&handle_mutex,&attr);
pthread_mutex_init(&index_mutex,&attr);
pthread_mutex_init(&multi_handle_mutex,&attr);
pthread_mutex_init(&iterator_mutex,&attr);
pthread_mutex_init(&keys_iterator_mutex,&attr);
pthread_mutexattr_destroy(&attr);
}
#elif GRIB_OMP_THREADS
static int once = 0;
static omp_nest_lock_t handle_mutex;
static omp_nest_lock_t index_mutex;
static omp_nest_lock_t multi_handle_mutex;
static omp_nest_lock_t iterator_mutex;
static omp_nest_lock_t keys_iterator_mutex;
static void init()
{
GRIB_OMP_CRITICAL(lock_python)
{
if (once == 0)
{
omp_init_nest_lock(&handle_mutex);
omp_init_nest_lock(&index_mutex);
omp_init_nest_lock(&multi_handle_mutex);
omp_init_nest_lock(&iterator_mutex);
omp_init_nest_lock(&keys_iterator_mutex);
once = 1;
}
}
}
#endif
int GRIB_NULL=-1;
int GRIB_NULL_NEAREST=-1;
typedef struct l_grib_file l_grib_file;
struct l_grib_file {
int id;
FILE* f;
l_grib_file* next;
};
typedef struct l_grib_handle l_grib_handle;
struct l_grib_handle {
int id;
grib_handle* h;
l_grib_handle* next;
};
typedef struct l_grib_index l_grib_index;
struct l_grib_index {
int id;
grib_index* h;
l_grib_index* next;
};
typedef struct l_grib_multi_handle l_grib_multi_handle;
struct l_grib_multi_handle {
int id;
grib_multi_handle* h;
l_grib_multi_handle* next;
};
typedef struct l_grib_iterator l_grib_iterator;
struct l_grib_iterator {
int id;
grib_iterator* i;
l_grib_iterator* next;
};
typedef struct l_grib_keys_iterator l_grib_keys_iterator;
struct l_grib_keys_iterator {
int id;
grib_keys_iterator* i;
l_grib_keys_iterator* next;
};
typedef struct l_bufr_keys_iterator l_bufr_keys_iterator;
struct l_bufr_keys_iterator {
int id;
bufr_keys_iterator* i;
l_bufr_keys_iterator* next;
};
static l_grib_handle* handle_set = NULL;
static l_grib_index* index_set = NULL;
static l_grib_multi_handle* multi_handle_set = NULL;
static l_grib_file* file_set = NULL;
static l_grib_iterator* iterator_set = NULL;
static l_grib_keys_iterator* keys_iterator_set = NULL;
static l_bufr_keys_iterator* bufr_keys_iterator_set = NULL;
static int push_file(FILE* f){
l_grib_file* current = file_set;
l_grib_file* previous = file_set;
l_grib_file* new = NULL;
int myindex = 1;
if(!file_set){
file_set = malloc(sizeof(l_grib_file));
file_set->id = myindex;
file_set->f = f;
file_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->f = f;
return current->id ;
} else{
myindex++;
previous = current;
current = current->next;
}
}
new = malloc(sizeof(l_grib_handle));
new->id = myindex;
new->f = f;
new->next = current;
previous->next = new;
return myindex;
}
static void _push_handle(grib_handle *h,int *gid)
{
l_grib_handle* current= handle_set;
l_grib_handle* previous= handle_set;
l_grib_handle* new= NULL;
int myindex= 1;
if (*gid > 0 ) {
while(current) {
if(current->id == *gid) break;
current = current->next;
}
if (current) {
grib_handle_delete(current->h);
current->h=h;
return;
}
}
current= handle_set;
if(!handle_set){
handle_set = malloc(sizeof(l_grib_handle));
handle_set->id = myindex;
handle_set->h = h;
handle_set->next = NULL;
*gid=myindex;
return;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->h = h;
*gid=current->id;
return;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
new = malloc(sizeof(l_grib_handle));
new->id = myindex;
new->h = h;
new->next = current;
previous->next = new;
*gid=myindex;
return;
}
static void _push_index(grib_index *h,int *gid)
{
l_grib_index* current= index_set;
l_grib_index* previous= index_set;
l_grib_index* new= NULL;
int myindex= 1;
if (*gid > 0 ) {
while(current) {
if(current->id == *gid) break;
current = current->next;
}
if (current) {
grib_index_delete(current->h);
current->h=h;
return;
}
}
current= index_set;
if(!index_set){
index_set = malloc(sizeof(l_grib_index));
index_set->id = myindex;
index_set->h = h;
index_set->next = NULL;
*gid=myindex;
return;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->h = h;
*gid=current->id;
return;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
new = malloc(sizeof(l_grib_index));
new->id = myindex;
new->h = h;
new->next = current;
previous->next = new;
*gid=myindex;
return;
}
static void _push_multi_handle(grib_multi_handle *h,int *gid)
{
l_grib_multi_handle* current= multi_handle_set;
l_grib_multi_handle* previous= multi_handle_set;
l_grib_multi_handle* new= NULL;
int myindex= 1;
if (*gid > 0 ) {
while(current) {
if(current->id == *gid) break;
current = current->next;
}
if (current) {
grib_multi_handle_delete(current->h);
current->h=h;
return;
}
}
current= multi_handle_set;
if(!multi_handle_set){
multi_handle_set = malloc(sizeof(l_grib_multi_handle));
multi_handle_set->id = myindex;
multi_handle_set->h = h;
multi_handle_set->next = NULL;
*gid=myindex;
return;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->h = h;
*gid=current->id;
return;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
new = malloc(sizeof(l_grib_multi_handle));
new->id = myindex;
new->h = h;
new->next = current;
previous->next = new;
*gid=myindex;
return;
}
static void push_handle(grib_handle *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&handle_mutex)
_push_handle(h,gid);
GRIB_MUTEX_UNLOCK(&handle_mutex)
return;
}
static void push_index(grib_index *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&index_mutex)
_push_index(h,gid);
GRIB_MUTEX_UNLOCK(&index_mutex)
return;
}
static void push_multi_handle(grib_multi_handle *h,int *gid)
{
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&multi_handle_mutex)
_push_multi_handle(h,gid);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex)
return;
}
static int _push_iterator(grib_iterator *i)
{
l_grib_iterator* current = iterator_set;
l_grib_iterator* previous = iterator_set;
l_grib_iterator* new = NULL;
int myindex = 1;
if(!iterator_set){
iterator_set = malloc(sizeof(l_grib_iterator));
iterator_set->id = myindex;
iterator_set->i = i;
iterator_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->i = i;
return current->id;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
new = malloc(sizeof(l_grib_iterator));
new->id = myindex;
new->i = i;
new->next = current;
previous->next = new;
return myindex;
}
static int push_iterator(grib_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&iterator_mutex)
ret=_push_iterator(i);
GRIB_MUTEX_UNLOCK(&iterator_mutex)
return ret;
}
static int _push_keys_iterator(grib_keys_iterator *i)
{
l_grib_keys_iterator* current = keys_iterator_set;
l_grib_keys_iterator* previous = keys_iterator_set;
l_grib_keys_iterator* new = NULL;
int myindex = 1;
if(!keys_iterator_set){
keys_iterator_set = malloc(sizeof(l_grib_keys_iterator));
keys_iterator_set->id = myindex;
keys_iterator_set->i = i;
keys_iterator_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->i = i;
return current->id;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
if(!previous) return -1;
new = malloc(sizeof(l_grib_keys_iterator));
new->id = myindex;
new->i = i;
new->next = current;
previous->next = new;
return myindex;
}
static int push_keys_iterator(grib_keys_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret=_push_keys_iterator(i);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
}
//BUFR keys iterator
static int _push_bufr_keys_iterator(bufr_keys_iterator *i)
{
l_bufr_keys_iterator* current = bufr_keys_iterator_set;
l_bufr_keys_iterator* previous = bufr_keys_iterator_set;
l_bufr_keys_iterator* the_new = NULL;
int myindex = 1;
if(!bufr_keys_iterator_set){
bufr_keys_iterator_set = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
Assert(bufr_keys_iterator_set);
bufr_keys_iterator_set->id = myindex;
bufr_keys_iterator_set->i = i;
bufr_keys_iterator_set->next = NULL;
return myindex;
}
while(current){
if(current->id < 0){
current->id = -(current->id);
current->i = i;
return current->id;
}
else{
myindex++;
previous = current;
current = current->next;
}
}
if(!previous) return -1;
the_new = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
Assert(the_new);
the_new->id = myindex;
the_new->i = i;
the_new->next = current;
previous->next = the_new;
return myindex;
}
static int push_bufr_keys_iterator(bufr_keys_iterator *i)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_push_bufr_keys_iterator(i);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
}
static grib_handle* _get_handle(int handle_id)
{
l_grib_handle* current= handle_set;
while(current){
if(current->id == handle_id) return current->h;
current = current->next;
}
return NULL;
}
static grib_index* _get_index(int index_id)
{
l_grib_index* current= index_set;
while(current){
if(current->id == index_id) return current->h;
current = current->next;
}
return NULL;
}
static grib_multi_handle* _get_multi_handle(int multi_handle_id)
{
l_grib_multi_handle* current= multi_handle_set;
while(current){
if(current->id == multi_handle_id) return current->h;
current = current->next;
}
return NULL;
}
static grib_handle* get_handle(int handle_id)
{
grib_handle* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&handle_mutex)
h=_get_handle(handle_id);
GRIB_MUTEX_UNLOCK(&handle_mutex)
return h;
}
static grib_index* get_index(int index_id)
{
grib_index* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&index_mutex)
h=_get_index(index_id);
GRIB_MUTEX_UNLOCK(&index_mutex)
return h;
}
static grib_multi_handle* get_multi_handle(int multi_handle_id)
{
grib_multi_handle* h=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&multi_handle_mutex)
h=_get_multi_handle(multi_handle_id);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex)
return h;
}
static FILE* get_file(int file_id)
{
l_grib_file* current = file_set;
while(current){
if(current->id == file_id) return current->f;
current = current->next;
}
return NULL;
}
static grib_iterator* _get_iterator(int iterator_id)
{
l_grib_iterator* current = iterator_set;
while(current){
if(current->id == iterator_id) return current->i;
current = current->next;
}
return NULL;
}
static grib_iterator* get_iterator(int iterator_id)
{
grib_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&iterator_mutex)
i=_get_iterator(iterator_id);
GRIB_MUTEX_UNLOCK(&iterator_mutex)
return i;
}
static grib_keys_iterator* _get_keys_iterator(int keys_iterator_id)
{
l_grib_keys_iterator* current = keys_iterator_set;
while(current){
if(current->id == keys_iterator_id) return current->i;
current = current->next;
}
return NULL;
}
static grib_keys_iterator* get_keys_iterator(int keys_iterator_id)
{
grib_keys_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
i=_get_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return i;
}
//BUFR keys iterator
static bufr_keys_iterator* _get_bufr_keys_iterator(int keys_iterator_id)
{
l_bufr_keys_iterator* current = bufr_keys_iterator_set;
while(current){
if(current->id == keys_iterator_id) return current->i;
current = current->next;
}
return NULL;
}
static bufr_keys_iterator* get_bufr_keys_iterator(int keys_iterator_id)
{
bufr_keys_iterator* i=NULL;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
i=_get_bufr_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return i;
}
static int clear_file(int file_id)
{
l_grib_file* current = file_set;
int ret = 0;
while(current){
if(current->id == file_id){
current->id = -(current->id);
if (current->f) {
ret = fclose(current->f);
if (0 == ret) {
return GRIB_SUCCESS;
} else {
return GRIB_IO_PROBLEM;
}
}
return GRIB_SUCCESS;
}
current = current->next;
}
return GRIB_INVALID_FILE;
}
static int _clear_handle(int handle_id)
{
l_grib_handle* current = handle_set;
/* look for the input grib id to release it */
while(current){
if(current->id == handle_id){
current->id = -(current->id);
if(current->h) return grib_handle_delete(current->h);
}
current = current->next;
}
/* fail with invalid grib id if not found */
return GRIB_INVALID_GRIB;
}
static int _clear_index(int index_id)
{
l_grib_index* current = index_set;
while(current){
if(current->id == index_id){
current->id = -(current->id);
if (current->h) {
grib_index_delete(current->h);
return GRIB_SUCCESS;
}
}
current = current->next;
}
return GRIB_SUCCESS;
}
static int _clear_multi_handle(int multi_handle_id)
{
l_grib_multi_handle* current = multi_handle_set;
while(current){
if(current->id == multi_handle_id){
current->id = -(current->id);
if(current->h) return grib_multi_handle_delete(current->h);
}
current = current->next;
}
return GRIB_SUCCESS;
}
static int clear_handle(int handle_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&handle_mutex)
ret=_clear_handle(handle_id);
GRIB_MUTEX_UNLOCK(&handle_mutex)
return ret;
}
static int clear_index(int index_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&index_mutex)
ret=_clear_index(index_id);
GRIB_MUTEX_UNLOCK(&index_mutex)
return ret;
}
static int clear_multi_handle(int multi_handle_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&multi_handle_mutex)
ret=_clear_multi_handle(multi_handle_id);
GRIB_MUTEX_UNLOCK(&multi_handle_mutex)
return ret;
}
static int _clear_iterator(int iterator_id)
{
l_grib_iterator* current = iterator_set;
while(current){
if(current->id == iterator_id){
current->id = -(current->id);
return grib_iterator_delete(current->i);
}
current = current->next;
}
return GRIB_INVALID_ITERATOR;
}
static int clear_iterator(int iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&iterator_mutex)
ret=_clear_iterator(iterator_id);
GRIB_MUTEX_UNLOCK(&iterator_mutex)
return ret;
}
static int _clear_keys_iterator(int keys_iterator_id)
{
l_grib_keys_iterator* current = keys_iterator_set;
while(current){
if(current->id == keys_iterator_id){
current->id = -(current->id);
return grib_keys_iterator_delete(current->i);
}
current = current->next;
}
return GRIB_INVALID_KEYS_ITERATOR;
}
static int clear_keys_iterator(int keys_iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret=_clear_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
}
//BUFR keys iterator
static int _clear_bufr_keys_iterator(int keys_iterator_id)
{
l_bufr_keys_iterator* current = bufr_keys_iterator_set;
while(current){
if(current->id == keys_iterator_id){
current->id = -(current->id);
return codes_bufr_keys_iterator_delete(current->i);
}
current = current->next;
}
return GRIB_INVALID_KEYS_ITERATOR;
}
static int clear_bufr_keys_iterator(int keys_iterator_id)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&keys_iterator_mutex);
ret=_clear_bufr_keys_iterator(keys_iterator_id);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
return ret;
}
int grib_c_read_any_from_file(int* fid, char* buffer, int* nbytes)
{
grib_context* c;
int err=0;
size_t size=(size_t)nbytes;
FILE* f=get_file(*fid);
if (f) {
c=grib_context_get_default( );
err=grib_read_any_from_file(c,f,buffer,&size);
*nbytes=size;
return err;
} else {
return GRIB_INVALID_FILE;
}
}
int grib_c_write_file(int* fid, char* buffer, size_t* nbytes)
{
grib_context* c;
FILE* f=get_file(*fid);
if (f) {
int ioerr;
c=grib_context_get_default( );
if( fwrite(buffer, 1, *nbytes, f) != *nbytes) {
ioerr=errno;
grib_context_log(c,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s",strerror(ioerr));
return GRIB_IO_PROBLEM;
}
return GRIB_SUCCESS;
} else {
return GRIB_INVALID_FILE;
}
}
int grib_c_read_file(int* fid, char* buffer, size_t* nbytes)
{
grib_context* c;
FILE* f=get_file(*fid);
if (f) {
int ioerr;
c=grib_context_get_default( );
if( fread(buffer, 1, *nbytes, f) != *nbytes) {
ioerr=errno;
grib_context_log(c,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s",strerror(ioerr));
return GRIB_IO_PROBLEM;
}
return GRIB_SUCCESS;
} else {
return GRIB_INVALID_FILE;
}
}
int grib_c_open_file(int* fid, char* name , char* op)
{
FILE* f = NULL;
int ioerr=0;
int ret=GRIB_SUCCESS;
/*TODO Proper context passed as external parameter */
grib_context* context=grib_context_get_default();
f = fopen(name,op);
if(!f) {
ioerr=errno;
grib_context_log(context,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s: %s",strerror(ioerr),name);
*fid = -1;
ret=GRIB_IO_PROBLEM;
} else {
*fid = push_file(f);
ret=GRIB_SUCCESS;
}
return ret;
}
int grib_c_close_file(int* fid){
return clear_file(*fid);
}
int grib_c_multi_support_on(void) {
grib_multi_support_on(0);
return GRIB_SUCCESS;
}
int grib_c_multi_support_off(void) {
grib_multi_support_off(0);
return GRIB_SUCCESS;
}
static int _grib_c_iterator_new_(int* gid,int* iterid,int* mode)
{
int err=0;
grib_handle* h;
grib_iterator* iter;
h=get_handle(*gid);
if (!h) {
*iterid=-1;
return GRIB_NULL_HANDLE;
}
iter=grib_iterator_new(h,*mode,&err);
if (iter)
*iterid=push_iterator(iter);
else
*iterid=-1;
return err;
}
int grib_c_iterator_new(int* gid,int* iterid,int* mode)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&iterator_mutex)
ret=_grib_c_iterator_new_(gid,iterid,mode);
GRIB_MUTEX_UNLOCK(&iterator_mutex)
return ret;
}
int grib_c_iterator_next(int* iterid,double* lat,double* lon,double* value)
{
grib_iterator* iter=get_iterator(*iterid);
if (!iter) return GRIB_INVALID_ITERATOR;
return grib_iterator_next(iter,lat,lon,value);
}
int grib_c_iterator_delete(int* iterid)
{
return clear_iterator(*iterid);
}
static int _grib_c_keys_iterator_new_(int* gid,int* iterid,char* name_space)
{
int err=0;
grib_handle* h;
grib_keys_iterator* iter;
h=get_handle(*gid);
if (!h) {
*iterid=-1;
return GRIB_NULL_HANDLE;
}
iter=grib_keys_iterator_new(h,0,name_space);
if (iter)
*iterid=push_keys_iterator(iter);
else
*iterid=-1;
return err;
}
int grib_c_keys_iterator_new(int* gid,int* iterid,char* name_space)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret=_grib_c_keys_iterator_new_(gid,iterid,name_space);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
}
int grib_c_keys_iterator_next(int* iterid)
{
int ret = 0;
grib_keys_iterator* iter= get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
ret = grib_keys_iterator_next(iter);
return ret;
}
int grib_c_keys_iterator_delete(int* iterid)
{
return clear_keys_iterator(*iterid);
}
int grib_c_keys_iterator_get_name(int* iterid,char* name,int len)
{
size_t lsize=len;
char buf[1024]={0,};
grib_keys_iterator* kiter=get_keys_iterator(*iterid);
if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
if (grib_keys_iterator_get_accessor(kiter)==NULL)
return GRIB_INVALID_KEYS_ITERATOR;
sprintf(buf,"%s",grib_keys_iterator_get_name(kiter));
lsize=strlen(buf);
if ((size_t)len < lsize) return GRIB_ARRAY_TOO_SMALL;
memcpy(name,buf,lsize);
name[lsize] = '\0';
return 0;
}
int grib_c_keys_iterator_rewind(int* kiter)
{
grib_keys_iterator* i=get_keys_iterator(*kiter);
if (!i) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_rewind(i);
}
/*BUFR keys iterator*/
static int _codes_c_bufr_keys_iterator_new_(int* gid,int* iterid)
{
int err=0;
grib_handle* h;
bufr_keys_iterator* iter;
h=get_handle(*gid);
if (!h) {
*iterid=-1;
return GRIB_NULL_HANDLE;
}
iter=codes_bufr_keys_iterator_new(h,0);
if (iter)
*iterid=push_bufr_keys_iterator(iter);
else
*iterid=-1;
return err;
}
int codes_c_bufr_keys_iterator_new(int* gid,int* iterid)
{
int ret=0;
GRIB_MUTEX_INIT_ONCE(&once,&init)
GRIB_MUTEX_LOCK(&keys_iterator_mutex)
ret = _codes_c_bufr_keys_iterator_new_(gid,iterid);
GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
return ret;
}
int codes_c_bufr_keys_iterator_next(int* iterid)
{
int ret = 0;
bufr_keys_iterator* iter= get_bufr_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
ret = codes_bufr_keys_iterator_next(iter);
return ret;
}
int codes_c_bufr_keys_iterator_get_name(int* iterid,char* name,int len)
{
size_t lsize=len;
char buf[1024]={0,};
bufr_keys_iterator* kiter=get_bufr_keys_iterator(*iterid);
if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
if (codes_bufr_keys_iterator_get_accessor(kiter)==NULL)
return GRIB_INVALID_KEYS_ITERATOR;
sprintf(buf,"%s",codes_bufr_keys_iterator_get_name(kiter));
lsize=strlen(buf);
if ((size_t)len < lsize) return GRIB_ARRAY_TOO_SMALL;
memcpy(name,buf,lsize);
name[lsize] = '\0';
return 0;
}
int codes_c_bufr_keys_iterator_rewind(int* kiter)
{
bufr_keys_iterator* i=get_bufr_keys_iterator(*kiter);
if (!i) return GRIB_INVALID_KEYS_ITERATOR;
return codes_bufr_keys_iterator_rewind(i);
}
int codes_c_bufr_keys_iterator_delete(int* iterid)
{
return clear_bufr_keys_iterator(*iterid);
}
int grib_c_gribex_mode_on(void)
{
grib_gribex_mode_on(0);
return GRIB_SUCCESS;
}
int grib_c_gribex_mode_off(void)
{
grib_gribex_mode_off(0);
return GRIB_SUCCESS;
}
int grib_c_skip_computed(int* iterid)
{
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_COMPUTED);
}
int grib_c_skip_coded(int* iterid)
{
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_CODED);
}
int grib_c_skip_edition_specific(int* iterid)
{
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_EDITION_SPECIFIC);
}
int grib_c_skip_duplicates(int* iterid)
{
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_DUPLICATES);
}
int grib_c_skip_read_only(int* iterid)
{
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_READ_ONLY);
}
int grib_c_skip_function(int* iterid)
{
grib_keys_iterator* iter=get_keys_iterator(*iterid);
if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_FUNCTION);
}
int grib_c_new_from_message(int* gid, void* buffer , size_t* bufsize)
{
grib_handle *h = NULL;
h = grib_handle_new_from_message_copy(0, buffer, *bufsize);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_INTERNAL_ERROR;
}
int grib_c_new_from_message_copy(int* gid, void* buffer , size_t* bufsize)
{
grib_handle *h = NULL;
h = grib_handle_new_from_message_copy(0, buffer, *bufsize);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_INTERNAL_ERROR;
}
int grib_c_grib_new_from_samples(int* gid, char* name)
{
grib_handle *h = NULL;
h = grib_handle_new_from_samples(NULL,name);
/* grib_context_set_debug(h->context,1);*/
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_FILE_NOT_FOUND;
}
int grib_c_bufr_new_from_samples(int* gid, char* name)
{
grib_handle *h = NULL;
h = codes_bufr_handle_new_from_samples(NULL,name);
/* grib_context_set_debug(h->context,1);*/
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
}
*gid = -1;
return GRIB_FILE_NOT_FOUND;
}
int grib_c_clone(int* gidsrc,int* giddest)
{
grib_handle *src = get_handle(*gidsrc);
grib_handle *dest = NULL;
if(src){
dest = grib_handle_clone(src);
if(dest){
push_handle(dest,giddest);
return GRIB_SUCCESS;
}
}
*giddest = -1;
return GRIB_INVALID_GRIB;
}
int grib_c_copy_namespace(int* gidsrc,char* name,int* giddest)
{
grib_handle *src = get_handle(*gidsrc);
grib_handle *dest = get_handle(*giddest);
if(src && dest)
return grib_copy_namespace(dest,name,src);
return GRIB_INVALID_GRIB;
}
/* ------------------------------------------------- */
typedef struct file_info_cache_t file_info_cache_t;
struct file_info_cache_t {
file_info_cache_t* next;
int file_descriptor;
FILE* file_pointer;
};
static file_info_cache_t* file_info_cache=0;
static void store_file_info(int fd, FILE* fp)
{
file_info_cache_t* tb=(file_info_cache_t*)malloc(sizeof(file_info_cache_t));
tb->file_descriptor = fd;
tb->file_pointer = fp;
tb->next = NULL;
//printf("store_file_info: fd=%d fp=%p\n",fd,fp);
if (!file_info_cache) {
file_info_cache = tb;
} else {
/*Add to end of linked list*/
file_info_cache_t* q = file_info_cache;
while(q->next) q=q->next;
q->next = tb;
}
}
static FILE* retrieve_file_info(int fd)
{
file_info_cache_t* p = file_info_cache;
//printf("retrieve_file_info: fd=%d\n",fd);
while (p) {
if (p->file_descriptor == fd) {
//printf("\t result=%p\n",p->file_pointer);
return p->file_pointer;
}
p = p->next;
}
//printf("\t result=NULL\n");
return NULL;
}
static int clear_file_info(int fd)
{
//printf("clear_file_info: fd=%d\n",fd);
file_info_cache_t *curr, *prev=NULL;
for(curr=file_info_cache; curr!=NULL; prev=curr, curr=curr->next) {
if (curr->file_descriptor==fd) {//found it
if(prev==NULL) {//fix head
file_info_cache = curr->next;
} else {
//Fix previous node's 'next' to skip over the removed node
prev->next = curr->next;
}
//printf("clear_file_info:\t Deleting entry curr (%d,%p)\n", curr->file_descriptor,curr->file_pointer);
free(curr);
return GRIB_SUCCESS;
}
}
return GRIB_INVALID_FILE;
}
#if DEBUG
static void dump_file_info(const char* title)
{
int i=1;
file_info_cache_t* curr = file_info_cache;
if(!curr) printf("%s: dump_file_info: EMPTY\n", title);
else printf("%s: dump_file_info:\n", title);
while(curr) {
printf("%s:\t %d: fd=%d fp=%p\n", title, i++,curr->file_descriptor,curr->file_pointer);
curr=curr->next;
}
}
#endif
/* ------------------------------------------------- */
int codes_c_close_file(int fd, char* fname)
{
FILE* fp = retrieve_file_info(fd);
//printf("codes_c_close_file: looking for %d\n", fd);
if (fp) {
clear_file_info(fd);
//dump_file_info("codes_c_close_file: clearing cache");
//} else {
//printf("codes_c_close_file: %d NOT IN CACHE\n", fd);
}
return GRIB_SUCCESS;
}
int grib_c_count_in_file(FILE* f,int* n)
{
int err = 0;
if (f) err=grib_count_in_file(0, f,n);
return err;
}
int grib_c_new_gts_from_file(FILE* f, int fd, char* fname, int headers_only, int* gid)
{
grib_handle *h = NULL;
int err = 0;
if(f){
FILE* p = retrieve_file_info(fd);
if (p) {
h = gts_new_from_file(0,p,&err); //use cached value
} else {
h = gts_new_from_file(0,f,&err); //use FILE pointer passed in
store_file_info(fd, f); //store it for next time
}
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
clear_file_info(fd);
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_c_new_metar_from_file(FILE* f,int headers_only, int* gid)
{
grib_handle *h = NULL;
int err = 0;
if(f){
h = metar_new_from_file(0,f,&err);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_c_new_any_from_file(FILE* f, int fd, char* fname, int headers_only,int* gid)
{
grib_handle *h = NULL;
int err = 0;
if(f){
FILE* p = retrieve_file_info(fd);
if (p) {
h = codes_handle_new_from_file(0,p,PRODUCT_ANY, &err);//use cached value
} else {
h = codes_handle_new_from_file(0,f,PRODUCT_ANY, &err);//use FILE pointer passed in
store_file_info(fd, f); //store it for next time
}
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
clear_file_info(fd);
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_c_new_bufr_from_file(FILE* f, int fd, char* fname, int headers_only,int* gid)
{
grib_handle *h = NULL;
int err = 0;
if(f){
FILE* p = retrieve_file_info(fd);
if (p) {
h = codes_handle_new_from_file(0,p,PRODUCT_BUFR, &err); //use cached value
} else {
h = codes_handle_new_from_file(0,f,PRODUCT_BUFR, &err); //use FILE pointer passed in
store_file_info(fd, f); //store it for next time
}
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
clear_file_info(fd);
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_c_new_from_file(FILE* f, int fd, char* fname, int* gid, int headers_only)
{
grib_handle *h = NULL;
int err = 0;
#if 0
printf("C grib_c_new_from_file: FILE*=%p\n", f);
printf("C grib_c_new_from_file: f->fileno=%d (fd=%d)\n", f->_fileno, fd);
printf("C grib_c_new_from_file: fn=%s\n", fname);
#endif
//dump_file_info("grib_c_new_from_file start");
if(f){
FILE* p = retrieve_file_info(fd);
if (p) {
//printf("C. using CACHED value from store...%p\n",p);
h=grib_new_from_file(0,p,headers_only,&err);//use cached value
} else {
//printf("C. using value from ARGS...%p\n",f);
h=grib_new_from_file(0,f,headers_only,&err);//use FILE pointer passed in
store_file_info(fd, f); //store it for next time
//dump_file_info("grib_c_new_from_file First time called");
}
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
if (err == GRIB_SUCCESS) {
//printf("C grib_c_new_from_file: GRIB_END_OF_FILE\n");
clear_file_info(fd);
//dump_file_info("grib_c_new_from_file EOF");
return GRIB_END_OF_FILE; //TODO: remove element from cache
} else {
/* A real error occurred */
return err;
}
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_c_new_from_index(int* iid, int* gid){
int err = 0;
grib_index* i = get_index(*iid);
grib_handle *h = NULL;
if(i){
h = grib_handle_new_from_index(i,&err);
if(h){
push_handle(h,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_INDEX;
}
}
*gid=-1;
return GRIB_INVALID_INDEX;
}
int grib_c_index_new_from_file(char* file ,char* keys ,int* gid){
int err = 0;
grib_index *i = NULL;
if(*file){
i = grib_index_new_from_file(0,file,keys,&err);
if(i){
push_index(i,gid);
return GRIB_SUCCESS;
} else {
*gid=-1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
int grib_c_index_add_file(int* iid, char* file) {
grib_index *i = get_index(*iid);
int err = GRIB_SUCCESS;
if (!i) {
return GRIB_INVALID_INDEX;
} else {
err = grib_index_add_file(i,file);
return err;
}
}
int grib_c_index_release(int* hid){
return clear_index(*hid);
}
int grib_c_multi_release(int* hid){
return clear_multi_handle(*hid);
}
int grib_c_release(int* hid){
return clear_handle(*hid);
}
int grib_c_dump(int* gid){
grib_handle *h = get_handle(*gid);
if(!h)
return GRIB_INVALID_GRIB;
else
grib_dump_content(h,stdout,"wmo",0,NULL);
return GRIB_SUCCESS;
}
int grib_c_print(int* gid, char* key){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
grib_dumper* d = NULL;
if(!h){
return GRIB_INVALID_GRIB;
}else{
d = grib_dumper_factory("serialize",h,stdout,0,0);
err = grib_print(h, key, d);
grib_dumper_delete(d);
return err;
}
}
int grib_c_get_error_string(int* err, char* buf, int len){
const char* err_msg = grib_get_error_message(*err);
size_t erlen = strlen(err_msg);
if( (size_t)len < erlen) return GRIB_ARRAY_TOO_SMALL;
strncpy(buf, err_msg,(size_t)erlen);
buf[erlen] = '\0';
return GRIB_SUCCESS;
}
int grib_c_get_size_int(int* gid, char* key, int* val){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_get_size(h, key, &tsize);
*val = tsize;
return err;
}
}
int grib_c_get_message_offset(int* gid, size_t* offset){
int err = GRIB_SUCCESS;
off_t myoffset;
grib_handle *h = get_handle(*gid);
if(!h)
return GRIB_INVALID_GRIB;
else {
err=grib_get_message_offset(h, &myoffset);
*offset=myoffset;
return err;
}
}
int grib_c_get_message_size(int* gid, size_t* size){
grib_handle *h = get_handle(*gid);
if(!h)
return GRIB_INVALID_GRIB;
else
return grib_get_message_size(h, size);
}
int grib_c_get_string_length(int* gid, char* key, size_t* val){
grib_handle *h = get_handle(*gid);
if(!h)
return GRIB_INVALID_GRIB;
else
return grib_get_string_length(h, key, val);
}
int grib_c_get_size_long(int* gid, char* key, long* val){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_get_size(h, key, &tsize);
*val = tsize;
return err;
}
}
int grib_c_index_get_size_int(int* gid, char* key, int* val){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_index_get_size(h, key, &tsize);
*val = tsize;
return err;
}
}
int grib_c_index_get_size_long(int* gid, char* key, long* val){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
size_t tsize = 0;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_index_get_size(h, key, &tsize);
*val = tsize;
return err;
}
}
int grib_c_get_int(int* gid, char* key, int* val){
grib_handle *h = get_handle(*gid);
long long_val;
int err = GRIB_SUCCESS;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_long(h, key,&long_val);
*val = long_val;
return err;
}
int grib_c_get_long(int* gid, char* key, long* val){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_long(h, key, val);
return err;
}
int grib_c_get_double(int* gid, char* key, double* val){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_double(h, key, val);
return err;
}
int grib_c_get_int_array(int* gid, char* key, int *val, size_t* size){
grib_handle *h = get_handle(*gid);
long* long_val = NULL;
int err = GRIB_SUCCESS;
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
if(sizeof(long) == sizeof(int)){
long_val = (long*)val;
err = grib_get_long_array(h, key, long_val, &lsize);
*size = lsize;
return err;
}
if(*size)
long_val = grib_context_malloc(h->context,(*size)*(sizeof(long)));
else
long_val = grib_context_malloc(h->context,(sizeof(long)));
if(!long_val) return GRIB_OUT_OF_MEMORY;
err = grib_get_long_array(h, key, long_val, &lsize);
for(*size=0;*size<lsize;(*size)++)
val[*size] = long_val[*size];
grib_context_free(h->context,long_val);
return err;
}
int grib_c_get_long_array(int* gid, char* key, long *val, int* size){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_long_array(h, key, val, &lsize);
*size=lsize;
return err;
}
int grib_c_index_get_string(int* gid, char* key, char* val, int *eachsize,int* size){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
size_t i;
size_t lsize = *size;
char** bufval;
char* p=val;
if(!h) return GRIB_INVALID_GRIB;
bufval=(char**)grib_context_malloc_clear(h->context,sizeof(char*)* *size);
err = grib_index_get_string(h, key, bufval, &lsize);
*size = lsize;
if (err) return err;
for (i=0;i<lsize;i++) {
int l=strlen(bufval[i]);
int j;
if (*eachsize < l ) {
grib_context_free(h->context,bufval);
printf("eachsize=%d strlen(bufval[i])=%d\n",*eachsize,(int)strlen(bufval[i]));
return GRIB_ARRAY_TOO_SMALL;
}
memcpy(p,bufval[i],l);
p+=l;
for (j=0;j<*eachsize-l;j++) *(p++)=' ';
}
grib_context_free(h->context,bufval);
return err;
}
int grib_c_index_get_long(int* gid, char* key, long *val, int* size){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_index_get_long(h, key, val, &lsize);
*size = lsize;
return err;
}
int grib_c_index_get_int(int* gid, char* key, int *val, int* size){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
long* lval=0;
size_t i;
if(!h) return GRIB_INVALID_GRIB;
lval=grib_context_malloc(h->context,sizeof(long)* *size);
if (!lval) return GRIB_OUT_OF_MEMORY;
err = grib_index_get_long(h, key, lval, &lsize);
for (i=0;i<lsize;i++) val[i]=lval[i];
*size = lsize;
return err;
}
int grib_c_index_get_real8(int* gid, char* key, double *val, int* size){
grib_index *h = get_index(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
err = grib_index_get_double(h, key, val, &lsize);
*size = lsize;
return err;
}
int grib_c_set_int_array(int* gid, char* key, int* val, size_t* size){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
long* long_val = NULL;
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
if(sizeof(long) == sizeof(int)){
long_val = (long*)val;
return grib_set_long_array(h, key, long_val, lsize);
}
if(lsize)
long_val = grib_context_malloc(h->context,(lsize)*(sizeof(long)));
else
long_val = grib_context_malloc(h->context,(sizeof(long)));
if(!long_val) return GRIB_OUT_OF_MEMORY;
for(lsize=0;lsize<(*size);lsize++)
long_val[lsize] = val[lsize];
err = grib_set_long_array(h, key, long_val, lsize);
grib_context_free(h->context,long_val);
return err;
}
int grib_c_set_long_array(int* gid, char* key, long* val, int* size){
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_long_array(h, key, val, lsize);
return err;
}
int grib_c_set_int(int* gid, char* key, int* val){
grib_handle *h = get_handle(*gid);
long long_val = *val;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_long(h, key, long_val);
}
int grib_c_set_long(int* gid, char* key, long* val){
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_set_long(h, key, *val);
}
int grib_c_set_missing(int* gid, char* key){
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_set_missing(h, key);
}
/*
* Submits all keys with the given values in one go.
* 'keyvals' is a string of the form:
* key1=val1,key2=val2,key3=val3
*/
int grib_c_set_key_vals(int* gid, char* keyvals)
{
grib_handle* h = get_handle(*gid);
if (!h) return GRIB_INVALID_GRIB;
{
int err = GRIB_SUCCESS;
grib_values values[1024]={{0,},};
int count = 1000; /* max. num key/val pairs */
if ((err = parse_keyval_string(NULL, keyvals, 1, GRIB_TYPE_UNDEFINED, values, &count)) != GRIB_SUCCESS) {
return err;
}
if ((err = grib_set_values(h,values,count)) != GRIB_SUCCESS) {
return err;
}
}
return GRIB_SUCCESS;
}
int grib_c_is_missing(int* gid, char* key,int* isMissing)
{
int err=0;
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
*isMissing=grib_is_missing(h, key,&err);
return err;
}
int grib_c_is_defined(int* gid, char* key,int* isDefined)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
*isDefined=grib_is_defined(h, key);
return GRIB_SUCCESS;
}
int grib_c_set_real4(int* gid, char* key, float* val)
{
grib_handle *h = get_handle(*gid);
double val8 = *val;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double(h, key, val8);
}
int grib_c_get_real4_element(int* gid, char* key, int* index,float* val)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
double val8 = 0;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_double_element(h, key, *index,&val8);
*val = val8;
return err;
}
int grib_c_get_real4_elements(int* gid, char* key,int* index, float *val,int* size)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
size_t i=0;
double* val8 = NULL;
if(!h) return GRIB_INVALID_GRIB;
if(*size)
val8 = grib_context_malloc(h->context,(*size)*(sizeof(double)));
else
val8 = grib_context_malloc(h->context,sizeof(double));
if(!val8) return GRIB_OUT_OF_MEMORY;
err = grib_get_double_elements(h, key, index,(long)lsize,val8);
for(i=0; i<lsize; i++)
val[i] = val8[i];
grib_context_free(h->context,val8);
return err;
}
int grib_c_get_real4(int* gid, char* key, float* val)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
double val8 = 0;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_double(h, key, &val8);
*val = val8;
return err;
}
int grib_c_get_real4_array(int* gid, char* key, float *val, size_t* size)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
double* val8 = NULL;
if(!h) return GRIB_INVALID_GRIB;
if(*size)
val8 = grib_context_malloc(h->context,(*size)*(sizeof(double)));
else
val8 = grib_context_malloc(h->context,sizeof(double));
if(!val8) return GRIB_OUT_OF_MEMORY;
err = grib_get_double_array(h, key, val8, &lsize);
for(*size=0;*size<lsize;(*size)++)
val[*size] = val8[*size];
grib_context_free(h->context,val8);
return err;
}
int grib_c_set_real4_array(int* gid, char* key, float*val, int* size)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
double* val8 = NULL;
if(!h) return GRIB_INVALID_GRIB;
if(*size)
val8 = grib_context_malloc(h->context,lsize*(sizeof(double)));
else
val8 = grib_context_malloc(h->context,sizeof(double));
if(!val8) return GRIB_OUT_OF_MEMORY;
for(lsize=0; lsize<(size_t)*size; lsize++)
val8[lsize] = val[lsize];
err = grib_set_double_array(h, key, val8, lsize);
grib_context_free(h->context,val8);
return err;
}
int grib_c_index_select_real8(int* gid, char* key, double* val)
{
grib_index *h = get_index(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_index_select_double(h, key, *val);
}
int grib_c_index_select_string(int* gid, char* key, char* val)
{
grib_index *h = get_index(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_index_select_string(h, key, val);
}
int grib_c_index_select_int(int* gid, char* key, int* val)
{
grib_index *h = get_index(*gid);
long lval=*val;
if(!h) return GRIB_INVALID_GRIB;
return grib_index_select_long(h, key, lval);
}
int grib_c_index_select_long(int* gid, char* key, long* val)
{
grib_index *h = get_index(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_index_select_long(h, key, *val);
}
int grib_c_set_real8(int* gid, char* key, double* val)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double(h, key, *val);
}
int grib_c_get_real8(int* gid, char* key, double* val)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_get_double(h, key, val);
}
int grib_c_set_double(int *gid, char *key, double *val)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double(h, key, *val);
}
int grib_c_get_real8_element(int* gid, char* key,int* index, double* val)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_get_double_element(h, key, *index,val);
}
int grib_c_get_real8_elements(int* gid, char* key,int* index, double* val, int *size)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_get_double_elements(h, key, index,*size,val);
}
int grib_c_find_nearest_four_single(int* gid,int* is_lsm,
double* inlat,double* inlon,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes)
{
grib_nearest* nearest=NULL;
int err=0, result=0;
unsigned long flags=0;
size_t len=4;
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
nearest=grib_nearest_new(h,&err);
if (err!=GRIB_SUCCESS) return err;
result = grib_nearest_find(nearest,h,*inlat,*inlon,
flags,outlats,outlons,values,distances,indexes,&len);
grib_nearest_delete(nearest);
return result;
}
int grib_c_find_nearest_single(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_nearest_find_multiple(h,*is_lsm,
inlats,inlons,1,outlats,outlons,
values,distances,indexes);
}
int grib_c_find_nearest_multiple(int* gid,int* is_lsm,
double* inlats,double* inlons,
double* outlats,double* outlons,
double* values,double* distances,
int* indexes, int* npoints)
{
grib_handle *h = get_handle(*gid);
if(!h) return GRIB_INVALID_GRIB;
return grib_nearest_find_multiple(h,*is_lsm,
inlats,inlons,*npoints,outlats,outlons,
values,distances,indexes);
}
int grib_c_get_real8_array(int* gid, char* key, double*val, int* size)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t lsize = *size;
if(!h){
return GRIB_INVALID_GRIB;
}else{
err = grib_get_double_array(h, key, val, &lsize);
*size = lsize;
return err;
}
}
int grib_c_set_real8_array(int* gid, char* key, double*val, int* size)
{
grib_handle *h = get_handle(*gid);
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double_array(h, key, val, lsize);
}
int grib_c_set_double_array(int* gid, char* key, double*val, int* size)
{
grib_handle *h = get_handle(*gid);
size_t lsize = *size;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_double_array(h, key, val, lsize);
}
int grib_c_get_string(int* gid, char* key, char* val, size_t *lsize)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_string(h, key, val, lsize);
return err;
}
int grib_c_get_string_array(int* gid, char* key, char** val, size_t *lsize)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
if(!h) return GRIB_INVALID_GRIB;
err = grib_get_string_array(h, key, val, lsize);
return err;
}
int grib_c_set_string(int* gid, char* key, char* val, int len2)
{
grib_handle *h = get_handle(*gid);
size_t lsize = len2;
if(!h) return GRIB_INVALID_GRIB;
return grib_set_string(h, key, val, &lsize);
}
int grib_c_set_string_array(int *gid, char *key, const char **val)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
size_t lsize = 0;
if(!h) return GRIB_INVALID_GRIB;
/* Note: The array passed in will have its final entry as NULL */
/* so to find its size we just iterate thru it. */
/* See typemap for char** in swig interface file */
while(val[lsize]) {
++lsize;
}
err = grib_set_string_array(h, key, val, lsize);
return err;
}
int grib_c_get_data_real4(int* gid,float* lats, float* lons,float* values,size_t* size)
{
grib_handle *h = get_handle(*gid);
int err = GRIB_SUCCESS;
double *lat8=NULL,*lon8=NULL,*val8 = NULL;
size_t i=0;
if(!h) return GRIB_INVALID_GRIB;
val8 = grib_context_malloc(h->context,(*size)*(sizeof(double)));
if(!val8) return GRIB_OUT_OF_MEMORY;
lon8 = grib_context_malloc(h->context,(*size)*(sizeof(double)));
if(!lon8) return GRIB_OUT_OF_MEMORY;
lat8 = grib_context_malloc(h->context,(*size)*(sizeof(double)));
if(!lat8) return GRIB_OUT_OF_MEMORY;
err=grib_get_data(h,lat8,lon8,val8);
for(i=0;i<*size;i++) {
values[i] = val8[i];
lats[i] = lat8[i];
lons[i] = lon8[i];
}
grib_context_free(h->context,val8);
grib_context_free(h->context,lat8);
grib_context_free(h->context,lon8);
return err;
}
/*
int grib_c_get_data_real8(int* gid,double* lats, double* lons,double* values,size_t* size)
{
grib_handle *h = get_handle(*gid);
return grib_get_data(h,lats,lons,values);
}
*/
int grib_c_copy_message(int* gid, void* mess,size_t* len)
{
grib_handle *h = get_handle(*gid);
if(!h)
return GRIB_INVALID_GRIB;
if(*len < h->buffer->ulength) {
grib_context_log(h->context,GRIB_LOG_ERROR,"grib_copy_message: buffer=%ld message size=%ld",*len,h->buffer->ulength);
return GRIB_BUFFER_TOO_SMALL;
}
memcpy(mess,h->buffer->data,h->buffer->ulength);
*len=h->buffer->ulength;
return GRIB_SUCCESS;
}
int grib_c_bufr_copy_data(int *msgid_src, int *msgid_dst)
{
int err = 0;
grib_handle* src = get_handle(*msgid_src);
grib_handle* dest = get_handle(*msgid_dst);
if (!src || !dest) {
return GRIB_INVALID_GRIB;
}
err = codes_bufr_copy_data(src, dest);
return err;
}
void grib_c_check(int* err,char* call,char* str)
{
grib_context* c=grib_context_get_default();
if ( *err == GRIB_SUCCESS || *err == GRIB_END_OF_FILE ) return;
grib_context_log(c,GRIB_LOG_ERROR,"%s: %s %s",
call,str,grib_get_error_message(*err));
exit(*err);
}
int grib_c_write(int* gid, FILE* f)
{
int err = 0;
grib_handle *h = get_handle(*gid);
const void* mess = NULL;
size_t mess_len = 0;
if(!f) return GRIB_INVALID_FILE;
if (!h) return GRIB_INVALID_GRIB;
err = grib_get_message(h,&mess,&mess_len);
if (err) return err;
if(fwrite(mess,1, mess_len,f) != mess_len) {
perror("grib_write");
return GRIB_IO_PROBLEM;
}
err = fflush(f);
if(err) {
perror("write flush");
return GRIB_IO_PROBLEM;
}
return GRIB_SUCCESS;
}
int grib_c_multi_new(int* mgid)
{
grib_multi_handle *mh = grib_multi_handle_new(0);
if (!mh) return GRIB_INVALID_GRIB;
push_multi_handle(mh,mgid);
return GRIB_SUCCESS;
}
int grib_c_multi_write(int* gid, FILE* f)
{
grib_multi_handle *h = get_multi_handle(*gid);
if(!f) return GRIB_INVALID_FILE;
if (!h) return GRIB_INVALID_GRIB;
return grib_multi_handle_write(h,f);
}
int grib_c_multi_append(int* ingid, int* sec,int* mgid)
{
grib_handle *h = get_handle(*ingid);
grib_multi_handle *mh = get_multi_handle(*mgid);
if (!h) return GRIB_INVALID_GRIB;
if (!mh) {
mh=grib_multi_handle_new(h->context);
push_multi_handle(mh,mgid);
}
return grib_multi_handle_append(h,*sec,mh);
}
int grib_c_get_native_type(int* gid, char* key, int* type)
{
grib_handle *h = get_handle(*gid);
if (!h) return GRIB_INVALID_GRIB;
return grib_get_native_type(h, key, type);
}
int grib_c_index_write(int* gid, char* file)
{
grib_index *i = get_index(*gid);
int err = GRIB_SUCCESS;
if (!i) {
return GRIB_INVALID_GRIB;
} else {
err = grib_index_write(i,file);
return err;
}
}
int grib_c_index_read(char* file, int* gid)
{
int err = 0;
grib_index *i = NULL;
if (*file) {
i = grib_index_read(0,file,&err);
if (i) {
push_index(i,gid);
return GRIB_SUCCESS;
} else {
*gid = -1;
return GRIB_END_OF_FILE;
}
}
*gid=-1;
return GRIB_INVALID_FILE;
}
void no_fail_on_wrong_length(int flag)
{
grib_context *c = grib_context_get_default();
int value;
assert(c != NULL);
value = (flag != 0) ? 1 : 0;
c->no_fail_on_wrong_length = value;
}
void grib_c_gts_header_on(void)
{
grib_context *c = grib_context_get_default();
assert(c != NULL);
grib_gts_header_on(c);
}
void grib_c_gts_header_off(void)
{
grib_context *c = grib_context_get_default();
assert(c != NULL);
grib_gts_header_off(c);
}
long grib_c_get_api_version(void)
{
return grib_get_api_version();
}
int grib_c_get_message(int *gid, const void **msg, size_t *size)
{
grib_handle *h = get_handle(*gid);
return grib_get_message(h,msg,size);
}
void grib_c_set_definitions_path(const char* path)
{
grib_context *c = grib_context_get_default();
grib_context_set_definitions_path(c, path);
}
void grib_c_set_samples_path(const char* path)
{
grib_context *c = grib_context_get_default();
grib_context_set_samples_path(c, path);
}
Reference in New Issue View Git Blame Copy Permalink