static int value_count(grib_accessor* a, long* numberOfPoints)
{
grib_accessor_data_apply_boustrophedonic *self =(grib_accessor_data_apply_boustrophedonic*)a;
int ret=0;
*numberOfPoints=0;
ret=grib_get_long_internal(a->parent->h,self->numberOfPoints,numberOfPoints);
return ret;
}
static int value_count(grib_accessor* a,long* number_of_values)
{
grib_accessor_data_g1simple_packing *self =(grib_accessor_data_g1simple_packing*)a;
*number_of_values=0;
/* Special case for when values are cleared */
/*if(a->length == 0)
return 0;*/
return grib_get_long_internal(a->parent->h,self->number_of_values,number_of_values);
}
static int value_count(grib_accessor* a,long* numberOfSecondOrderPackedValues)
{
int err=0;
grib_accessor_data_g1second_order_constant_width_packing *self =(grib_accessor_data_g1second_order_constant_width_packing*)a;
*numberOfSecondOrderPackedValues=0;
err=grib_get_long_internal(grib_handle_of_accessor(a),self->numberOfSecondOrderPackedValues,numberOfSecondOrderPackedValues);
return err;
}
static int is_missing(grib_accessor* a)
{
grib_accessor_g2latlon* self = (grib_accessor_g2latlon*)a;
long given = 1;
if(self->given) grib_get_long_internal(a->parent->h, self->given,&given);
return !given;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=0;
grib_accessor_decimal_precision* self= (grib_accessor_decimal_precision*)a;
grib_handle* h=a->parent->h;
if((ret = grib_get_long_internal(h,self->decimal_scale_factor,val))
!= GRIB_SUCCESS) return ret;
*len =1;
return ret;
}
static int unpack_string(grib_accessor*a , char* v, size_t *len){
grib_accessor_md5* self = (grib_accessor_md5*)a;
unsigned mess_len;
unsigned char* mess;
unsigned char* p;
long offset,length;
grib_string_list* blacklist=NULL;
grib_accessor* b=NULL;
int ret=0;
int i=0;
struct grib_md5_state md5c;
if (*len <32 ) {
grib_context_log(a->context,GRIB_LOG_ERROR,"md5: array too small");
return GRIB_ARRAY_TOO_SMALL;
}
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->offset,&offset))
!= GRIB_SUCCESS)
return ret;
if((ret = grib_expression_evaluate_long(grib_handle_of_accessor(a),self->length,&length))
!= GRIB_SUCCESS)
return ret;
mess=(unsigned char*)grib_context_malloc(a->context,length);
memcpy(mess,grib_handle_of_accessor(a)->buffer->data+offset,length);
mess_len=length;
blacklist=a->context->blacklist;
/* passed blacklist overrides context blacklist.
Consider to modify following line to extend context blacklist.
*/
if (self->blacklist) blacklist=self->blacklist;
while (blacklist && blacklist->value) {
b=grib_find_accessor(grib_handle_of_accessor(a),blacklist->value);
if (!b) {
grib_context_free(a->context,mess);
return GRIB_NOT_FOUND;
}
p=mess+b->offset-offset;
for (i=0;i<b->length;i++) *(p++)=0;
blacklist=blacklist->next;
}
grib_md5_init(&md5c);
grib_md5_add(&md5c,mess,mess_len);
grib_md5_end(&md5c,v);
grib_context_free(a->context,mess);
return ret;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=GRIB_SUCCESS;
size_t size=0;
size_t i;
double max,min,d,b;
double *values=0;
long binaryScaleFactor,decimalScaleFactor;
grib_accessor_second_order_bits_per_value* self = (grib_accessor_second_order_bits_per_value*)a;
if (self->bitsPerValue) {
*val=self->bitsPerValue;
return GRIB_SUCCESS;
}
if((ret = grib_get_size(a->parent->h, self->values,&size)) != GRIB_SUCCESS) {
*val=self->bitsPerValue;
return GRIB_SUCCESS;
}
if((ret = grib_get_long(a->parent->h, self->binaryScaleFactor,&binaryScaleFactor)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h, self->decimalScaleFactor,&decimalScaleFactor)) != GRIB_SUCCESS)
return ret;
values=grib_context_malloc_clear(a->parent->h->context,sizeof(double)*size);
if (!values) {
grib_context_log(a->parent->h->context,GRIB_LOG_FATAL,"%s unable to allocate %ld bytes",
a->name,(long)size);
return GRIB_OUT_OF_MEMORY;
}
if((ret = grib_get_double_array_internal(a->parent->h, self->values,values,&size)) != GRIB_SUCCESS)
return ret;
max=values[0];
min=max;
for (i=1;i<size;i++) {
if (max<values[i]) max=values[i];
if (min>values[i]) min=values[i];
}
d=grib_power(-decimalScaleFactor,10);
b=grib_power(-binaryScaleFactor,2);
/* self->bitsPerValue=(long)ceil(log((double)((max-min)*d+1))/log(2.0))-binaryScaleFactor; */
self->bitsPerValue=number_of_bits((unsigned long)(fabs(max-min)*b*d));
*val=self->bitsPerValue;
grib_context_free(a->parent->h->context,values);
return ret;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=0;
grib_accessor_bits_per_value* self= (grib_accessor_bits_per_value*)a;
grib_handle* h=grib_handle_of_accessor(a);
if((ret = grib_get_long_internal(h,self->bits_per_value,val))
!= GRIB_SUCCESS) return ret;
*len =1;
return ret;
}
static long value_count(grib_accessor* a)
{
grib_accessor_g1bitmap* self = (grib_accessor_g1bitmap*)a;
long tlen;
int err;
if ((err=grib_get_long_internal(a->parent->h, self->unusedBits, &tlen)) != GRIB_SUCCESS)
grib_context_log(a->parent->h->context, GRIB_LOG_ERROR, "grib_accessor_class_bitmap.value_count : cannot get %s err=%d",self->unusedBits,err);
tlen = (a->length*8)-tlen;
return tlen;
}
static int value_count(grib_accessor* a,long* numberOfPoints)
{
grib_accessor_data_dummy_field* self = (grib_accessor_data_dummy_field*)a;
int err=0;
*numberOfPoints = 0;
if((err = grib_get_long_internal(a->parent->h,self->numberOfPoints, numberOfPoints))
!= GRIB_SUCCESS) {
grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"unable to get count of %s (%s)",a->name,grib_get_error_message(err));
}
return err;
}
static void compute_size(grib_accessor* a)
{
long slen = 0;
long off = 0;
grib_accessor_bitmap* self = (grib_accessor_bitmap*)a;
grib_get_long_internal(a->parent->h, self->offsetbsec,&off);
grib_get_long_internal(a->parent->h, self->sLength, &slen);
if(slen == 0)
{
grib_accessor* seclen;
size_t size;
/* Assume reparsing */
Assert(a->parent->h->loader != 0);
if (a->parent->h->loader != 0) {
seclen = grib_find_accessor(a->parent->h, self->sLength);
Assert(seclen);
grib_get_block_length(seclen->parent,&size);
slen = size;
}
}
#if 0
printf("compute_size off=%ld slen=%ld a->offset=%ld\n",
(long)off,(long)slen,(long)a->offset);
#endif
a->length = off+(slen-a->offset);
if(a->length < 0)
{
/* Assume reparsing */
/*Assert(a->parent->h->loader != 0);*/
a->length = 0;
}
Assert(a->length>=0);
}
static int unpack_long (grib_accessor* a, long* val, size_t *len)
{
int ret=0;
grib_handle* h=a->parent->h;
grib_accessor_gds_is_present* self = (grib_accessor_gds_is_present*)a;
if((ret = grib_get_long_internal(h,self->gds_present,val))
!= GRIB_SUCCESS) return ret;
*len=1;
return GRIB_SUCCESS;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_validity_date* self = (grib_accessor_validity_date*)a;
int ret=0;
long date = 0;
long time = 0;
long step = 0;
long stepUnits = 0;
long hours = 0, minutes=0, step_mins=0, tmp, tmp_hrs;
if (self->year) {
long year,month,day;
if ((ret=grib_get_long_internal(a->parent->h, self->year,&year))!=GRIB_SUCCESS) return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->month,&month))!=GRIB_SUCCESS) return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->day,&day))!=GRIB_SUCCESS) return ret;
*val=year*10000+month*100+day;
return GRIB_SUCCESS;
}
if ((ret=grib_get_long_internal(a->parent->h, self->date,&date))!=GRIB_SUCCESS) return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->time,&time))!=GRIB_SUCCESS) return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->step,&step))!=GRIB_SUCCESS) return ret;
if (self->stepUnits) {
if ((ret=grib_get_long_internal(a->parent->h, self->stepUnits,&stepUnits))!=GRIB_SUCCESS) return ret;
step_mins = convert_to_minutes(step, stepUnits);
}
minutes = time % 100;
hours = time / 100;
tmp = minutes + step_mins; /* add the step to our minutes */
tmp_hrs = tmp/60; /* how many hours and mins is that? */
/* tmp_mins = tmp%60; */
hours += tmp_hrs; /* increment hours */
date = grib_date_to_julian (date);
/* does the new 'hours' exceed 24? if so increment julian */
while(hours>=24) {
date ++;
hours -= 24;
}
/* GRIB-29: Negative forecast time */
while(hours<0) {
date--;
hours += 24;
}
if(*len < 1)
return GRIB_ARRAY_TOO_SMALL;
*val = grib_julian_to_date(date);
return GRIB_SUCCESS;
}
static int value_count(grib_accessor* a,long* count)
{
grib_accessor_data_sh_unpacked *self =(grib_accessor_data_sh_unpacked*)a;
int ret = 0;
long sub_j= 0;
long sub_k= 0;
long sub_m= 0;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_j,&sub_j)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_k,&sub_k)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->sub_m,&sub_m)) != GRIB_SUCCESS)
return ret;
if (sub_j != sub_k || sub_j!=sub_m ) {
grib_context_log(a->context,GRIB_LOG_ERROR,"sub_j=%ld, sub_k=%ld, sub_m=%ld\n",sub_j,sub_k,sub_m);
Assert ((sub_j == sub_k) && (sub_j == sub_m));
}
*count=(sub_j+1)*(sub_j+2);
return ret;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=0;
grib_accessor_budgdate* self = (grib_accessor_budgdate*)a;
long year = 0;
long month = 0;
long day = 0;
if ((ret=grib_get_long_internal(a->parent->h, self->day,&day))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->month,&month))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->year,&year))!=GRIB_SUCCESS)
return ret;
if(*len < 1)
return GRIB_WRONG_ARRAY_SIZE;
val[0] = (1900 + year) * 10000 + month * 100 + day;
return ret;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=GRIB_SUCCESS;
long ni=0,nj=0,plpresent=0;
size_t plsize=0;
long* pl;
int i;
grib_accessor_number_of_points* self = (grib_accessor_number_of_points*)a;
grib_context* c=a->context;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->ni,&ni)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->nj,&nj)) != GRIB_SUCCESS)
return ret;
if(self->plpresent &&
((ret = grib_get_long_internal(grib_handle_of_accessor(a), self->plpresent,&plpresent)) != GRIB_SUCCESS) )
return ret;
if (nj == 0) return GRIB_GEOCALCULUS_PROBLEM;
if (plpresent) {
/*reduced*/
plsize=nj;
pl=(long*)grib_context_malloc(c,sizeof(long)*plsize);
grib_get_long_array_internal(grib_handle_of_accessor(a),self->pl,pl, &plsize);
*val=0;
for (i=0;i<plsize;i++) *val+=pl[i];
grib_context_free(c,pl);
} else {
/*regular*/
*val=ni*nj;
}
return ret;
}
static int unpack_one_time_range(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_g2end_step* self = (grib_accessor_g2end_step*)a;
int err = 0;
long start_step;
long unit;
long coded_unit;
long coded_time_range, typeOfTimeIncrement;
int add_time_range = 1; /* whether we add lengthOfTimeRange */
grib_handle* h = a->parent->h;
if((err = grib_get_long_internal(h,self->start_step,&start_step))) return err;
if((err = grib_get_long_internal(h,self->unit,&unit))) return err;
if((err = grib_get_long_internal(h,self->coded_unit,&coded_unit))) return err;
if((err = grib_get_long_internal(h,self->coded_time_range, &coded_time_range))) return err;
if((err = grib_get_long_internal(h,self->typeOfTimeIncrement, &typeOfTimeIncrement))) return err;
err = convert_time_range(h, unit, coded_unit, &coded_time_range);
if (err != GRIB_SUCCESS) return err;
if (typeOfTimeIncrement == 1) {
/* See GRIB-488 */
/* Note: For this case, lengthOfTimeRange is not related to step and should not be used to calculate step */
add_time_range = 0;
if (is_special_expver(h)) {
add_time_range = 1;
}
}
if (add_time_range) {
*val = start_step + coded_time_range;
} else {
*val = start_step;
}
return GRIB_SUCCESS;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_step_in_units* self = (grib_accessor_step_in_units*)a;
int err = 0;
long codedStep,codedUnits,stepUnits;
grib_handle* h=grib_handle_of_accessor(a);
int factor=0;
long u2sf,u2sf_step_unit;
if((err = grib_get_long_internal(h,self->codedUnits,&codedUnits))) return err;
if((err = grib_get_long_internal(h,self->stepUnits,&stepUnits))) return err;
if((err = grib_get_long_internal(h,self->codedStep,&codedStep))) return err;
if (stepUnits!=codedUnits) {
*val=codedStep*u2s2[codedUnits];
if (*val<0) {
factor=60;
if (u2s2[codedUnits] % factor) return GRIB_DECODING_ERROR;
if (u2s[stepUnits] % factor) return GRIB_DECODING_ERROR;
u2sf=u2s2[codedUnits]/factor;
*val=codedStep*u2sf;
u2sf_step_unit=u2s[stepUnits]/factor;
} else {
u2sf_step_unit=u2s[stepUnits];
}
if (*val % u2sf_step_unit!=0) {
err = grib_set_long_internal(h,self->stepUnits,codedUnits);
*val=codedStep;
return err;
}
*val = *val / u2sf_step_unit;
} else *val=codedStep;
return GRIB_SUCCESS;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=GRIB_SUCCESS;
long bpv=0;
long offsetBeforeData=0,offsetAfterData=0,unusedBits=0,numberOfValues;
long JS=0,KS=0,MS=0,NS=0;
grib_accessor_g1number_of_coded_values_sh_complex* self = (grib_accessor_g1number_of_coded_values_sh_complex*)a;
if((ret = grib_get_long_internal(a->parent->h, self->bitsPerValue,&bpv)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h, self->offsetBeforeData,&offsetBeforeData)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h, self->offsetAfterData,&offsetAfterData)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h, self->unusedBits,&unusedBits)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h, self->JS,&JS)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h, self->KS,&KS)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h, self->MS,&MS)) != GRIB_SUCCESS)
return ret;
if (JS != KS || KS != MS) return GRIB_NOT_IMPLEMENTED;
NS=(MS+1)*(MS+2);
if ( bpv != 0 ) {
*val =((offsetAfterData-offsetBeforeData)*8-unusedBits+NS*(bpv-32))/bpv;
} else {
if((ret = grib_get_long_internal(a->parent->h, self->numberOfValues,&numberOfValues)) != GRIB_SUCCESS)
return ret;
*val=numberOfValues;
}
return ret;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
int ret=0;
grib_accessor_g1date* self = (grib_accessor_g1date*)a;
long year = 0;
long century = 0;
long month = 0;
long day = 0;
if ((ret=grib_get_long_internal(a->parent->h, self->century,¢ury))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->day,&day))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->month,&month))!=GRIB_SUCCESS)
return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->year,&year))!=GRIB_SUCCESS)
return ret;
if(*len < 1)
return GRIB_WRONG_ARRAY_SIZE;
*val = ((century-1)*100 + year) * 10000 + month * 100 + day;
if(year == 255 && day == 255 && month >= 1 && month <= 12)
{
*val = month;
}
if(year == 255 && day != 255 && month >= 1 && month <= 12)
{
*val = month * 100 + day;
}
return GRIB_SUCCESS;
}
static int unpack_double (grib_accessor* a, double* val, size_t *len) {
grib_accessor_simple_packing_error* self = (grib_accessor_simple_packing_error*)a;
int ret = 0;
long binaryScaleFactor=0;
long bitsPerValue=0;
long decimalScaleFactor=0;
double referenceValue=0;
if((ret = grib_get_long_internal(a->parent->h,
self->binaryScaleFactor,&binaryScaleFactor)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,
self->bitsPerValue,&bitsPerValue)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,
self->decimalScaleFactor,&decimalScaleFactor)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_double_internal(a->parent->h,
self->referenceValue,&referenceValue)) != GRIB_SUCCESS)
return ret;
if (!strcmp(self->floatType,"ibm"))
*val=grib_ibmfloat_error(referenceValue);
else if (!strcmp(self->floatType,"ieee"))
*val=grib_ieeefloat_error(referenceValue);
else Assert(1==0);
if (bitsPerValue!=0)
*val=(*val+grib_power(binaryScaleFactor,2))*grib_power(-decimalScaleFactor,10)*0.5;
if (ret == GRIB_SUCCESS) *len = 1;
return ret;
}
static long value_count(grib_accessor* a)
{
long number_of_values;
grib_accessor_data_g1second_order_row_by_row_packing *self =(grib_accessor_data_g1second_order_row_by_row_packing*)a;
/* Special case for when values are cleared */
/*if(a->length == 0)
return 0;*/
if(grib_get_long_internal(a->parent->h,self->number_of_values,&number_of_values) != GRIB_SUCCESS)
return 0;
return number_of_values;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_g1monthlydate* self = (grib_accessor_g1monthlydate*)a;
long date = 0;
grib_get_long_internal(a->parent->h, self->date,&date);
date /= 100;
date*=100;
date+=1;
*val = date;
return GRIB_SUCCESS;
}
static int unpack_double(grib_accessor* a, double* val, size_t *len)
{
grib_accessor_data_raw_packing *self =(grib_accessor_data_raw_packing*)a;
unsigned char* buf = NULL;
int bytes = 0;
size_t nvals = 0;
long inlen = grib_byte_count(a);
long precision = 0;
int code = GRIB_SUCCESS;
if((code = grib_get_long_internal(a->parent->h,self->precision,&precision))
!= GRIB_SUCCESS)
return code;
self->dirty=0;
buf = (unsigned char*)a->parent->h->buffer->data;
buf += grib_byte_offset(a);
switch(precision)
{
case 1:
bytes = 4;
break;
case 2:
bytes = 8;
break;
default:
return GRIB_NOT_IMPLEMENTED;
break;
}
nvals = inlen / bytes;
if(*len < nvals)
return GRIB_ARRAY_TOO_SMALL;
code=grib_ieee_decode_array(a->parent->h->context,buf,nvals,bytes,val);
*len = nvals;
return code;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
/* TODO properly calling grib_concept_evaluate_long ! */
const char *p = grib_concept_evaluate(a->parent->h,a->creator);
if(!p) {
if (a->creator->defaultkey)
return grib_get_long_internal(a->parent->h,a->creator->defaultkey,val);
return GRIB_NOT_FOUND;
}
*val = atol(p);
*len = 1;
return GRIB_SUCCESS;
}
static int unpack_double_element(grib_accessor* a, size_t idx, double* val) {
int ret=0;
grib_accessor_data_raw_packing *self =(grib_accessor_data_raw_packing*)a;
unsigned char* buf = NULL;
int bytes = 0;
size_t nvals = 0;
long inlen = grib_byte_count(a);
long pos;
long precision = 0;
if((ret = grib_get_long_internal(a->parent->h,self->precision,&precision))
!= GRIB_SUCCESS)
return ret;
self->dirty=0;
buf = (unsigned char*)a->parent->h->buffer->data;
buf += grib_byte_offset(a);
switch(precision)
{
case 1:
bytes = 4;
break;
case 2:
bytes = 8;
break;
default:
return GRIB_NOT_IMPLEMENTED;
break;
}
pos=bytes*idx;
Assert(pos<=inlen);
nvals = 1;
buf+=pos;
ret=grib_ieee_decode_array(a->parent->h->context,buf,nvals,bytes,val);
return ret;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
double* values=NULL;
size_t size=0;
double missingValue=0;
long missingValuesPresent = 0;
int ret=0,i=0;
grib_accessor_offset_values* self= (grib_accessor_offset_values*)a;
grib_context* c=a->context;
grib_handle* h=grib_handle_of_accessor(a);
if (*val==0) return GRIB_SUCCESS;
if((ret = grib_get_double_internal(h,self->missingValue,&missingValue)) != GRIB_SUCCESS) {
return ret;
}
if((ret=grib_get_long_internal(h,"missingValuesPresent",&missingValuesPresent)) != GRIB_SUCCESS) {
return ret;
}
if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret;
values=(double*)grib_context_malloc(c,size*sizeof(double));
if (!values) return GRIB_OUT_OF_MEMORY;
if((ret = grib_get_double_array_internal(h,self->values,values,&size)) != GRIB_SUCCESS) {
grib_context_free(c,values);
return ret;
}
for (i=0;i<size;i++) {
if (missingValuesPresent) {
if (values[i]!=missingValue) values[i]+=*val;
} else {
values[i]+=*val;
}
}
if((ret = grib_set_double_array_internal(h, self->values,values,size)) != GRIB_SUCCESS) return ret;
grib_context_free(c,values);
return GRIB_SUCCESS;
}
static int unpack_long(grib_accessor* a, long* val, size_t *len)
{
grib_accessor_validity_time* self = (grib_accessor_validity_time*)a;
int ret=0;
long date = 0;
long time = 0;
long step = 0;
long stepUnits = 0;
long hours = 0, minutes=0, step_mins=0, tmp, tmp_hrs, tmp_mins;
if (self->hours) {
long hours,minutes;
if ((ret=grib_get_long_internal(a->parent->h, self->hours,&hours))!=GRIB_SUCCESS) return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->minutes,&minutes))!=GRIB_SUCCESS) return ret;
*val=hours*100+minutes;
return GRIB_SUCCESS;
}
if ((ret=grib_get_long_internal(a->parent->h, self->date,&date))!=GRIB_SUCCESS) return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->time,&time))!=GRIB_SUCCESS) return ret;
if ((ret=grib_get_long_internal(a->parent->h, self->step,&step))!=GRIB_SUCCESS) return ret;
/* Seconds will always be zero. So convert to minutes */
if (self->stepUnits) {
if ((ret=grib_get_long_internal(a->parent->h, self->stepUnits,&stepUnits))!=GRIB_SUCCESS) return ret;
step_mins = convert_to_minutes(step, stepUnits);
}
minutes = time % 100;
hours = time / 100;
tmp = minutes + step_mins; /* add the step to our minutes */
tmp_hrs = tmp/60; /* how many hours and mins is that? */
tmp_mins = tmp%60;
hours += tmp_hrs; /* increment hours */
if (hours>0) {
hours = hours % 24; /* wrap round if >= 24 */
} else {
/* GRIB-29: Negative forecast time */
while (hours<0) {
hours += 24;
}
}
time = hours * 100 + tmp_mins;
if(*len < 1)
return GRIB_ARRAY_TOO_SMALL;
*val = time;
return GRIB_SUCCESS;
}
static int value_count(grib_accessor* a,long* count)
{
int err=0;
grib_accessor_data_2order_packing* self = (grib_accessor_data_2order_packing*)a;
long two_ordr_spd = 0;
long plus1_spd = 0;
grib_handle* gh = grib_handle_of_accessor(a);
unsigned char* buf_size_of_groups = (unsigned char*)gh->buffer->data;
long octet_start_group = 0;
long offsetsection = 0;
long nbits_per_lengths = 0;
long pointer_of_group_size = 0;
long p1 = 0;
long extraValues=0;
size_t i = 0;
if((err=grib_get_long_internal(gh,self->two_ordr_spd, &two_ordr_spd)) != GRIB_SUCCESS)
return err;
if( (err=grib_get_long_internal(gh,self->plus1_spd, &plus1_spd)) != GRIB_SUCCESS)
return err;
if( (err=grib_get_long_internal(gh,self->width_lengths, &nbits_per_lengths)) != GRIB_SUCCESS)
return err;
if( (err=grib_get_long_internal(gh,self->offsetsection, &offsetsection)) != GRIB_SUCCESS)
return err;
if( (err=grib_get_long_internal(gh,self->octet_start_group, &octet_start_group)) != GRIB_SUCCESS)
return err;
if( (err=grib_get_long_internal(gh,self->p1, &p1)) != GRIB_SUCCESS)
return err;
if( (err=grib_get_long_internal(gh,self->extraValues, &extraValues)) != GRIB_SUCCESS)
return err;
p1+=extraValues*65536;
buf_size_of_groups += offsetsection+(octet_start_group-1);
*count = two_ordr_spd*2+plus1_spd;
for(i=0;i < p1;i++)
*count += grib_decode_unsigned_long(buf_size_of_groups, &pointer_of_group_size, nbits_per_lengths);
return err;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_dummy_field* self = (grib_accessor_data_dummy_field*)a;
size_t n_vals = *len;
int err = 0;
long bits_per_value = 0;
long half_byte = 0;
size_t buflen = 0;
unsigned char* buf = NULL;
if (*len ==0) return GRIB_NO_VALUES;
if((err = grib_get_long_internal(a->parent->h,self->bits_per_value,&bits_per_value)) != GRIB_SUCCESS)
return err;
buflen = (1+((bits_per_value*n_vals)/8))*sizeof(unsigned char);
buf = (unsigned char*)grib_context_malloc_clear(a->parent->h->context,buflen);
if (!buf) return GRIB_OUT_OF_MEMORY;
half_byte = (buflen*8)-((*len)*bits_per_value);
if((err = grib_set_long_internal(a->parent->h,self->half_byte, half_byte)) != GRIB_SUCCESS) {
grib_context_free(a->parent->h->context,buf);
return err;
}
grib_buffer_replace(a, buf, buflen,1,1);
grib_context_free(a->parent->h->context,buf);
return GRIB_SUCCESS;
}
