static int
read_map(avro_reader_t reader, const avro_encoding_t * enc,
avro_consumer_t *consumer, void *ud)
{
int rval;
int64_t i; /* index within the current block */
int64_t index = 0; /* index within the entire array */
int64_t block_count;
int64_t block_size;
check_prefix(rval, enc->read_long(reader, &block_count),
"Cannot read map block count: ");
check(rval, avro_consumer_call(consumer, map_start_block,
1, block_count, ud));
while (block_count != 0) {
if (block_count < 0) {
block_count = block_count * -1;
check_prefix(rval, enc->read_long(reader, &block_size),
"Cannot read map block size: ");
}
for (i = 0; i < block_count; i++, index++) {
char *key;
int64_t key_size;
avro_consumer_t *element_consumer = NULL;
void *element_ud = NULL;
check_prefix(rval, enc->read_string(reader, &key, &key_size),
"Cannot read map key: ");
rval = avro_consumer_call(consumer, map_element,
index, key,
&element_consumer, &element_ud,
ud);
if (rval) {
avro_free(key, key_size);
return rval;
}
rval = avro_consume_binary(reader, element_consumer, element_ud);
if (rval) {
avro_free(key, key_size);
return rval;
}
avro_free(key, key_size);
}
check_prefix(rval, enc->read_long(reader, &block_count),
"Cannot read map block count: ");
check(rval, avro_consumer_call(consumer, map_start_block,
0, block_count, ud));
}
return 0;
}
void avro_raw_array_done(avro_raw_array_t *array)
{
if (array->data) {
avro_free(array->data, array->allocated_size);
}
memset(array, 0, sizeof(avro_raw_array_t));
}
static int reset_snappy(avro_codec_t c)
{
if (c->block_data) {
avro_free(c->block_data, c->block_size);
}
c->block_data = NULL;
c->block_size = 0;
c->used_size = 0;
c->codec_data = NULL;
return 0;
}
int
avro_consume_binary(avro_reader_t reader, avro_consumer_t *consumer, void *ud)
{
int rval;
const avro_encoding_t *enc = &avro_binary_encoding;
check_param(EINVAL, reader, "reader");
check_param(EINVAL, consumer, "consumer");
switch (avro_typeof(consumer->schema)) {
case AVRO_NULL:
check_prefix(rval, enc->read_null(reader),
"Cannot read null value: ");
check(rval, avro_consumer_call(consumer, null_value, ud));
break;
case AVRO_BOOLEAN:
{
int8_t b;
check_prefix(rval, enc->read_boolean(reader, &b),
"Cannot read boolean value: ");
check(rval, avro_consumer_call(consumer, boolean_value, b, ud));
}
break;
case AVRO_STRING:
{
int64_t len;
char *s;
check_prefix(rval, enc->read_string(reader, &s, &len),
"Cannot read string value: ");
check(rval, avro_consumer_call(consumer, string_value, s, len, ud));
}
break;
case AVRO_INT32:
{
int32_t i;
check_prefix(rval, enc->read_int(reader, &i),
"Cannot read int value: ");
check(rval, avro_consumer_call(consumer, int_value, i, ud));
}
break;
case AVRO_INT64:
{
int64_t l;
check_prefix(rval, enc->read_long(reader, &l),
"Cannot read long value: ");
check(rval, avro_consumer_call(consumer, long_value, l, ud));
}
break;
case AVRO_FLOAT:
{
float f;
check_prefix(rval, enc->read_float(reader, &f),
"Cannot read float value: ");
check(rval, avro_consumer_call(consumer, float_value, f, ud));
}
break;
case AVRO_DOUBLE:
{
double d;
check_prefix(rval, enc->read_double(reader, &d),
"Cannot read double value: ");
check(rval, avro_consumer_call(consumer, double_value, d, ud));
}
break;
case AVRO_BYTES:
{
char *bytes;
int64_t len;
check_prefix(rval, enc->read_bytes(reader, &bytes, &len),
"Cannot read bytes value: ");
check(rval, avro_consumer_call(consumer, bytes_value, bytes, len, ud));
}
break;
case AVRO_FIXED:
{
char *bytes;
int64_t size =
avro_schema_to_fixed(consumer->schema)->size;
bytes = avro_malloc(size);
if (!bytes) {
avro_prefix_error("Cannot allocate new fixed value");
return ENOMEM;
}
rval = avro_read(reader, bytes, size);
if (rval) {
avro_prefix_error("Cannot read fixed value: ");
avro_free(bytes, size);
return rval;
}
rval = avro_consumer_call(consumer, fixed_value, bytes, size, ud);
if (rval) {
avro_free(bytes, size);
return rval;
}
}
break;
case AVRO_ENUM:
check(rval, read_enum(reader, enc, consumer, ud));
break;
case AVRO_ARRAY:
check(rval, read_array(reader, enc, consumer, ud));
break;
case AVRO_MAP:
check(rval, read_map(reader, enc, consumer, ud));
break;
case AVRO_UNION:
check(rval, read_union(reader, enc, consumer, ud));
break;
case AVRO_RECORD:
check(rval, read_record(reader, enc, consumer, ud));
break;
case AVRO_LINK:
avro_set_error("Consumer can't consume a link schema directly");
return EINVAL;
}
return 0;
}
void
avro_alloc_free_func(void *ptr, size_t sz)
{
avro_free(ptr, sz);
}
void avro_str_free(char *str)
{
size_t *size = ((size_t *) str) - 1;
//fprintf(stderr, "--- free %zu %p %s\n", *size, str, str);
avro_free(size, *size);
}
