/* unpack sphere from double and integer buffers (unpacking starts at dpos and ipos in
* d and i and no more than a specific number of doubles and ints can be red) */
SPHERE* SPHERE_Unpack (void *solfec, int *dpos, double *d, int doubles, int *ipos, int *i, int ints)
{
SPHERE *sph;
int j;
ERRMEM (sph = MEM_CALLOC (sizeof (SPHERE)));
sph->surface = unpack_int (ipos, i, ints);
sph->volume = unpack_int (ipos, i, ints);
unpack_doubles (dpos, d, doubles, sph->cur_center, 3);
unpack_doubles (dpos, d, doubles, (double*)sph->cur_point, 9);
sph->cur_radius = unpack_double (dpos, d, doubles);
unpack_doubles (dpos, d, doubles, sph->ref_center, 3);
unpack_doubles (dpos, d, doubles, (double*)sph->ref_point, 9);
sph->ref_radius = unpack_double (dpos, d, doubles);
j = unpack_int (ipos, i, ints); /* unpack material existence flag */
if (j)
{
SOLFEC *sol = solfec;
char *label = unpack_string (ipos, i, ints);
ASSERT_DEBUG_EXT (sph->mat = MATSET_Find (sol->mat, label), "Failed to find material when unpacking a sphere");
free (label);
}
return sph;
}
static int unpack_string(grib_accessor*a , char* v, size_t *len)
{
int ret=0;
double dval=0;
long lval=0;
size_t llen=1;
grib_accessor_class* super = NULL;
switch (get_native_type(a)) {
case GRIB_TYPE_LONG:
ret=unpack_long(a,&lval,&llen);
sprintf(v,"%ld",lval);
*len=strlen(v);
break;
case GRIB_TYPE_DOUBLE:
ret=unpack_double(a,&dval,&llen);
sprintf(v,"%g",dval);
*len=strlen(v);
break;
default:
super = *(a->cclass->super);
ret = super->unpack_string(a,v,len);
}
return ret;
}
static int unpack_string(grib_accessor* a, char* val, size_t *len)
{
char result[1024] ;
int ret = GRIB_SUCCESS;
size_t replen = 1;
double value = 0;
ret = unpack_double(a, &value, &replen);
sprintf(result,"%.3f",value);
replen = strlen(result)+1;
if(*len < replen) {
*len = replen;
return GRIB_ARRAY_TOO_SMALL;
}
*len = replen;
sprintf(val,"%s",result);
return GRIB_SUCCESS;
}
static int is_missing(grib_accessor* a){
size_t len=1;
double val=0;
unpack_double(a, &val, &len);
return (val == GRIB_MISSING_DOUBLE);
}
static int unpack_long (grib_accessor* a, long* val, size_t *len)
{
int ret=0;
double v=0;
ret=unpack_double(a,&v,len);
*val=(long)v;
return ret;
}
static PyObject *
lu_double(const char *p, const formatdef *f)
{
return unpack_double(p, 1);
}
static ssize_t
dec_double(amqp_value_t *v, mnbytestream_t *bs, int fd)
{
return unpack_double(bs, fd, &v->value.d);
}
bool
UNPACK_VALUE(serial_context *ser_cont, as_val **value)
{
int32_t type = READ_CHAR(ser_cont->fd, ser_cont->line_no, ser_cont->col_no, ser_cont->bytes);
if (type == EOF) {
err("Error while reading value type");
return false;
}
switch (type) {
case 0xc0: // nil
return unpack_nil(ser_cont, value);
case 0xc3: // boolean true
return unpack_boolean(ser_cont, true, value);
case 0xc2: // boolean false
return unpack_boolean(ser_cont, false, value);
case 0xca: { // float
float tmp;
return extract_float(ser_cont, &tmp) && unpack_double(ser_cont, tmp, value);
}
case 0xcb: { // double
double tmp;
return extract_double(ser_cont, &tmp) && unpack_double(ser_cont, tmp, value);
}
case 0xd0: { // signed 8 bit integer
int8_t tmp;
return extract_uint8(ser_cont, (uint8_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xcc: { // unsigned 8 bit integer
uint8_t tmp;
return extract_uint8(ser_cont, &tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xd1: { // signed 16 bit integer
int16_t tmp;
return extract_uint16(ser_cont, (uint16_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xcd: { // unsigned 16 bit integer
uint16_t tmp;
return extract_uint16(ser_cont, &tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xd2: { // signed 32 bit integer
int32_t tmp;
return extract_uint32(ser_cont, (uint32_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xce: { // unsigned 32 bit integer
uint32_t tmp;
return extract_uint32(ser_cont, &tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xd3: { // signed 64 bit integer
int64_t tmp;
return extract_uint64(ser_cont, (uint64_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xcf: { // unsigned 64 bit integer
uint64_t tmp;
return extract_uint64(ser_cont, &tmp) && unpack_integer(ser_cont, (int64_t)tmp, value);
}
case 0xc4:
case 0xd9: { // raw bytes with 8 bit header
uint8_t size;
return extract_uint8(ser_cont, &size) && unpack_blob(ser_cont, size, value);
}
case 0xc5:
case 0xda: { // raw bytes with 16 bit header
uint16_t size;
return extract_uint16(ser_cont, &size) && unpack_blob(ser_cont, size, value);
}
case 0xc6:
case 0xdb: { // raw bytes with 32 bit header
uint32_t size;
return extract_uint32(ser_cont, &size) && unpack_blob(ser_cont, size, value);
}
case 0xdc: { // list with 16 bit header
uint16_t size;
return extract_uint16(ser_cont, &size) && unpack_list(ser_cont, size, value);
}
case 0xdd: { // list with 32 bit header
uint32_t size;
return extract_uint32(ser_cont, &size) && unpack_list(ser_cont, size, value);
}
case 0xde: { // map with 16 bit header
uint16_t size;
return extract_uint16(ser_cont, &size) && unpack_map(ser_cont, size, value);
}
case 0xdf: { // map with 32 bit header
uint32_t size;
return extract_uint32(ser_cont, &size) && unpack_map(ser_cont, size, value);
}
default:
if ((type & 0xe0) == 0xa0) { // raw bytes with 8 bit combined header
return unpack_blob(ser_cont, type & 0x1f, value);
}
if ((type & 0xf0) == 0x80) { // map with 8 bit combined header
return unpack_map(ser_cont, type & 0x0f, value);
}
if ((type & 0xf0) == 0x90) { // list with 8 bit combined header
return unpack_list(ser_cont, type & 0x0f, value);
}
if (type < 0x80) { // 8 bit combined unsigned integer
return unpack_integer(ser_cont, type, value);
}
if (type >= 0xe0) { // 8 bit combined signed integer
return unpack_integer(ser_cont, type - 0xe0 - 32, value);
}
return false;
}
}
