| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to you under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| */ |
| |
| #include <avro/platform.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "avro_private.h" |
| #include "avro/allocation.h" |
| #include "avro/basics.h" |
| #include "avro/data.h" |
| #include "avro/errors.h" |
| #include "avro/refcount.h" |
| #include "avro/resolver.h" |
| #include "avro/schema.h" |
| #include "avro/value.h" |
| #include "st.h" |
| |
| #ifndef AVRO_RESOLVER_DEBUG |
| #define AVRO_RESOLVER_DEBUG 0 |
| #endif |
| |
| #if AVRO_RESOLVER_DEBUG |
| #include <stdio.h> |
| #define DEBUG(...) \ |
| do { \ |
| fprintf(stderr, __VA_ARGS__); \ |
| fprintf(stderr, "\n"); \ |
| } while (0) |
| #else |
| #define DEBUG(...) /* don't print messages */ |
| #endif |
| |
| |
| typedef struct avro_resolved_reader avro_resolved_reader_t; |
| |
| struct avro_resolved_reader { |
| avro_value_iface_t parent; |
| |
| /** The reference count for this interface. */ |
| volatile int refcount; |
| |
| /** The writer schema. */ |
| avro_schema_t wschema; |
| |
| /** The reader schema. */ |
| avro_schema_t rschema; |
| |
| /* The size of the value instances for this resolver. */ |
| size_t instance_size; |
| |
| /* A function to calculate the instance size once the overall |
| * top-level resolver (and all of its children) have been |
| * constructed. */ |
| void |
| (*calculate_size)(avro_resolved_reader_t *iface); |
| |
| /* A free function for this resolver */ |
| void |
| (*free_iface)(avro_resolved_reader_t *iface, st_table *freeing); |
| |
| /* An initialization function for instances of this resolver. */ |
| int |
| (*init)(const avro_resolved_reader_t *iface, void *self); |
| |
| /* A finalization function for instances of this resolver. */ |
| void |
| (*done)(const avro_resolved_reader_t *iface, void *self); |
| |
| /* Clear out any existing wrappers, if any */ |
| int |
| (*reset_wrappers)(const avro_resolved_reader_t *iface, void *self); |
| }; |
| |
| #define avro_resolved_reader_calculate_size(iface) \ |
| do { \ |
| if ((iface)->calculate_size != NULL) { \ |
| (iface)->calculate_size((iface)); \ |
| } \ |
| } while (0) |
| #define avro_resolved_reader_init(iface, self) \ |
| ((iface)->init == NULL? 0: (iface)->init((iface), (self))) |
| #define avro_resolved_reader_done(iface, self) \ |
| ((iface)->done == NULL? (void) 0: (iface)->done((iface), (self))) |
| #define avro_resolved_reader_reset_wrappers(iface, self) \ |
| ((iface)->reset_wrappers == NULL? 0: \ |
| (iface)->reset_wrappers((iface), (self))) |
| |
| |
| /* |
| * We assume that each instance type in this value contains an an |
| * avro_value_t as its first element, which is the current wrapped |
| * value. |
| */ |
| |
| void |
| avro_resolved_reader_set_source(avro_value_t *resolved, |
| avro_value_t *dest) |
| { |
| avro_value_t *self = (avro_value_t *) resolved->self; |
| if (self->self != NULL) { |
| avro_value_decref(self); |
| } |
| avro_value_copy_ref(self, dest); |
| } |
| |
| void |
| avro_resolved_reader_clear_source(avro_value_t *resolved) |
| { |
| avro_value_t *self = (avro_value_t *) resolved->self; |
| if (self->self != NULL) { |
| avro_value_decref(self); |
| } |
| self->iface = NULL; |
| self->self = NULL; |
| } |
| |
| int |
| avro_resolved_reader_new_value(avro_value_iface_t *viface, |
| avro_value_t *value) |
| { |
| int rval; |
| avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| void *self = avro_malloc(iface->instance_size + sizeof(volatile int)); |
| if (self == NULL) { |
| value->iface = NULL; |
| value->self = NULL; |
| return ENOMEM; |
| } |
| |
| memset(self, 0, iface->instance_size + sizeof(volatile int)); |
| volatile int *refcount = (volatile int *) self; |
| self = (char *) self + sizeof(volatile int); |
| |
| rval = avro_resolved_reader_init(iface, self); |
| if (rval != 0) { |
| avro_free(self, iface->instance_size + sizeof(volatile int)); |
| value->iface = NULL; |
| value->self = NULL; |
| return rval; |
| } |
| |
| *refcount = 1; |
| value->iface = avro_value_iface_incref(viface); |
| value->self = self; |
| return 0; |
| } |
| |
| static void |
| avro_resolved_reader_free_value(const avro_value_iface_t *viface, void *vself) |
| { |
| avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| avro_value_t *self = (avro_value_t *) vself; |
| |
| avro_resolved_reader_done(iface, vself); |
| if (self->self != NULL) { |
| avro_value_decref(self); |
| } |
| |
| vself = (char *) vself - sizeof(volatile int); |
| avro_free(vself, iface->instance_size + sizeof(volatile int)); |
| } |
| |
| static void |
| avro_resolved_reader_incref(avro_value_t *value) |
| { |
| /* |
| * This only works if you pass in the top-level value. |
| */ |
| |
| volatile int *refcount = (volatile int *) ((char *) value->self - sizeof(volatile int)); |
| avro_refcount_inc(refcount); |
| } |
| |
| static void |
| avro_resolved_reader_decref(avro_value_t *value) |
| { |
| /* |
| * This only works if you pass in the top-level value. |
| */ |
| |
| volatile int *refcount = (volatile int *) ((char *) value->self - sizeof(volatile int)); |
| if (avro_refcount_dec(refcount)) { |
| avro_resolved_reader_free_value(value->iface, value->self); |
| } |
| } |
| |
| |
| static avro_value_iface_t * |
| avro_resolved_reader_incref_iface(avro_value_iface_t *viface) |
| { |
| avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| avro_refcount_inc(&iface->refcount); |
| return viface; |
| } |
| |
| static void |
| free_resolver(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| /* First check if we've already started freeing this resolver. */ |
| if (st_lookup(freeing, (st_data_t) iface, NULL)) { |
| DEBUG("Already freed %p", iface); |
| return; |
| } |
| |
| /* Otherwise add this resolver to the freeing set, then free it. */ |
| st_insert(freeing, (st_data_t) iface, (st_data_t) NULL); |
| DEBUG("Freeing resolver %p (%s->%s)", iface, |
| avro_schema_type_name(iface->wschema), |
| avro_schema_type_name(iface->rschema)); |
| |
| iface->free_iface(iface, freeing); |
| } |
| |
| static void |
| avro_resolved_reader_calculate_size_(avro_resolved_reader_t *iface) |
| { |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for %s->%s", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| iface->instance_size = sizeof(avro_value_t); |
| } |
| |
| static void |
| avro_resolved_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| AVRO_UNUSED(freeing); |
| avro_schema_decref(iface->wschema); |
| avro_schema_decref(iface->rschema); |
| avro_freet(avro_resolved_reader_t, iface); |
| } |
| |
| static void |
| avro_resolved_reader_decref_iface(avro_value_iface_t *viface) |
| { |
| avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| DEBUG("Decref resolver %p (before=%d)", iface, iface->refcount); |
| if (avro_refcount_dec(&iface->refcount)) { |
| st_table *freeing = st_init_numtable(); |
| free_resolver(iface, freeing); |
| st_free_table(freeing); |
| } |
| } |
| |
| static int |
| avro_resolved_reader_reset(const avro_value_iface_t *viface, void *vself) |
| { |
| /* |
| * To reset a wrapped value, we first clear out any wrappers, |
| * and then have the wrapped value reset itself. |
| */ |
| |
| int rval; |
| avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| avro_value_t *self = (avro_value_t *) vself; |
| check(rval, avro_resolved_reader_reset_wrappers(iface, vself)); |
| return avro_value_reset(self); |
| } |
| |
| static avro_type_t |
| avro_resolved_reader_get_type(const avro_value_iface_t *viface, const void *vself) |
| { |
| AVRO_UNUSED(vself); |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| return avro_typeof(iface->rschema); |
| } |
| |
| static avro_schema_t |
| avro_resolved_reader_get_schema(const avro_value_iface_t *viface, const void *vself) |
| { |
| AVRO_UNUSED(vself); |
| avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| return iface->rschema; |
| } |
| |
| |
| static avro_resolved_reader_t * |
| avro_resolved_reader_create(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| avro_resolved_reader_t *self = (avro_resolved_reader_t *) avro_new(avro_resolved_reader_t); |
| memset(self, 0, sizeof(avro_resolved_reader_t)); |
| |
| self->parent.incref_iface = avro_resolved_reader_incref_iface; |
| self->parent.decref_iface = avro_resolved_reader_decref_iface; |
| self->parent.incref = avro_resolved_reader_incref; |
| self->parent.decref = avro_resolved_reader_decref; |
| self->parent.reset = avro_resolved_reader_reset; |
| self->parent.get_type = avro_resolved_reader_get_type; |
| self->parent.get_schema = avro_resolved_reader_get_schema; |
| |
| self->refcount = 1; |
| self->wschema = avro_schema_incref(wschema); |
| self->rschema = avro_schema_incref(rschema); |
| self->calculate_size = avro_resolved_reader_calculate_size_; |
| self->free_iface = avro_resolved_reader_free_iface; |
| self->reset_wrappers = NULL; |
| return self; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * Memoized resolvers |
| */ |
| |
| typedef struct avro_resolved_link_reader avro_resolved_link_reader_t; |
| |
| typedef struct memoize_state_t { |
| avro_memoize_t mem; |
| avro_resolved_link_reader_t *links; |
| } memoize_state_t; |
| |
| static avro_resolved_reader_t * |
| avro_resolved_reader_new_memoized(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema); |
| |
| |
| /*----------------------------------------------------------------------- |
| * Recursive schemas |
| */ |
| |
| /* |
| * Recursive schemas are handled specially; the value implementation for |
| * an AVRO_LINK schema is simply a wrapper around the value |
| * implementation for the link's target schema. The value methods all |
| * delegate to the wrapped implementation. |
| * |
| * Complicating the links here is that we might be linking to the writer |
| * schema or the reader schema. This only matters for a couple of |
| * methods, so instead of keeping a boolean flag in the value interface, |
| * we just have separate method implementations that we slot in |
| * appropriately. |
| */ |
| |
| struct avro_resolved_link_reader { |
| avro_resolved_reader_t parent; |
| |
| /** |
| * A pointer to the “next” link resolver that we've had to |
| * create. We use this as we're creating the overall top-level |
| * resolver to keep track of which ones we have to fix up |
| * afterwards. |
| */ |
| avro_resolved_link_reader_t *next; |
| |
| /** The target's implementation. */ |
| avro_resolved_reader_t *target_resolver; |
| }; |
| |
| typedef struct avro_resolved_link_value { |
| avro_value_t wrapped; |
| avro_value_t target; |
| } avro_resolved_link_value_t; |
| |
| static void |
| avro_resolved_wlink_reader_calculate_size(avro_resolved_reader_t *iface) |
| { |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for [%s]->%s", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| iface->instance_size = sizeof(avro_resolved_link_value_t); |
| } |
| |
| static void |
| avro_resolved_rlink_reader_calculate_size(avro_resolved_reader_t *iface) |
| { |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for %s->[%s]", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| iface->instance_size = sizeof(avro_resolved_link_value_t); |
| } |
| |
| static void |
| avro_resolved_link_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| avro_resolved_link_reader_t *liface = |
| container_of(iface, avro_resolved_link_reader_t, parent); |
| if (liface->target_resolver != NULL) { |
| free_resolver(liface->target_resolver, freeing); |
| } |
| avro_schema_decref(iface->wschema); |
| avro_schema_decref(iface->rschema); |
| avro_freet(avro_resolved_link_reader_t, iface); |
| } |
| |
| static int |
| avro_resolved_link_reader_init(const avro_resolved_reader_t *iface, void *vself) |
| { |
| int rval; |
| const avro_resolved_link_reader_t *liface = |
| container_of(iface, avro_resolved_link_reader_t, parent); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| size_t target_instance_size = liface->target_resolver->instance_size; |
| |
| self->target.iface = &liface->target_resolver->parent; |
| self->target.self = avro_malloc(target_instance_size); |
| if (self->target.self == NULL) { |
| return ENOMEM; |
| } |
| DEBUG("Allocated <%p:%" PRIsz "> for link", self->target.self, target_instance_size); |
| |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| |
| rval = avro_resolved_reader_init(liface->target_resolver, self->target.self); |
| if (rval != 0) { |
| avro_free(self->target.self, target_instance_size); |
| } |
| return rval; |
| } |
| |
| static void |
| avro_resolved_link_reader_done(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_link_reader_t *liface = |
| container_of(iface, avro_resolved_link_reader_t, parent); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| size_t target_instance_size = liface->target_resolver->instance_size; |
| DEBUG("Freeing <%p:%" PRIsz "> for link", self->target.self, target_instance_size); |
| avro_resolved_reader_done(liface->target_resolver, self->target.self); |
| avro_free(self->target.self, target_instance_size); |
| self->target.iface = NULL; |
| self->target.self = NULL; |
| } |
| |
| static int |
| avro_resolved_link_reader_reset(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_link_reader_t *liface = |
| container_of(iface, avro_resolved_link_reader_t, parent); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| return avro_resolved_reader_reset_wrappers |
| (liface->target_resolver, self->target.self); |
| } |
| |
| static avro_type_t |
| avro_resolved_link_reader_get_type(const avro_value_iface_t *iface, const void *vself) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_type(&self->target); |
| } |
| |
| static avro_schema_t |
| avro_resolved_link_reader_get_schema(const avro_value_iface_t *iface, const void *vself) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_schema(&self->target); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_boolean(const avro_value_iface_t *iface, |
| const void *vself, int *out) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_boolean(&self->target, out); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_bytes(const avro_value_iface_t *iface, |
| const void *vself, const void **buf, size_t *size) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_bytes(&self->target, buf, size); |
| } |
| |
| static int |
| avro_resolved_link_reader_grab_bytes(const avro_value_iface_t *iface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_grab_bytes(&self->target, dest); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_double(const avro_value_iface_t *iface, |
| const void *vself, double *out) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_double(&self->target, out); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_float(const avro_value_iface_t *iface, |
| const void *vself, float *out) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_float(&self->target, out); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_int(const avro_value_iface_t *iface, |
| const void *vself, int32_t *out) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_int(&self->target, out); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_long(const avro_value_iface_t *iface, |
| const void *vself, int64_t *out) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_long(&self->target, out); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_null(const avro_value_iface_t *iface, const void *vself) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_null(&self->target); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_string(const avro_value_iface_t *iface, |
| const void *vself, const char **str, size_t *size) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_string(&self->target, str, size); |
| } |
| |
| static int |
| avro_resolved_link_reader_grab_string(const avro_value_iface_t *iface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_grab_string(&self->target, dest); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_enum(const avro_value_iface_t *iface, |
| const void *vself, int *out) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_enum(&self->target, out); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_fixed(const avro_value_iface_t *iface, |
| const void *vself, const void **buf, size_t *size) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_fixed(&self->target, buf, size); |
| } |
| |
| static int |
| avro_resolved_link_reader_grab_fixed(const avro_value_iface_t *iface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_grab_fixed(&self->target, dest); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_boolean(const avro_value_iface_t *iface, |
| void *vself, int val) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_boolean(&self->target, val); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_bytes(const avro_value_iface_t *iface, |
| void *vself, void *buf, size_t size) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_bytes(&self->target, buf, size); |
| } |
| |
| static int |
| avro_resolved_link_reader_give_bytes(const avro_value_iface_t *iface, |
| void *vself, avro_wrapped_buffer_t *buf) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_give_bytes(&self->target, buf); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_double(const avro_value_iface_t *iface, |
| void *vself, double val) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_double(&self->target, val); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_float(const avro_value_iface_t *iface, |
| void *vself, float val) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_float(&self->target, val); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_int(const avro_value_iface_t *iface, |
| void *vself, int32_t val) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_int(&self->target, val); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_long(const avro_value_iface_t *iface, |
| void *vself, int64_t val) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_long(&self->target, val); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_null(const avro_value_iface_t *iface, void *vself) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_null(&self->target); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_string(const avro_value_iface_t *iface, |
| void *vself, const char *str) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_string(&self->target, str); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_string_len(const avro_value_iface_t *iface, |
| void *vself, const char *str, size_t size) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_string_len(&self->target, str, size); |
| } |
| |
| static int |
| avro_resolved_link_reader_give_string_len(const avro_value_iface_t *iface, |
| void *vself, avro_wrapped_buffer_t *buf) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_give_string_len(&self->target, buf); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_enum(const avro_value_iface_t *iface, |
| void *vself, int val) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_enum(&self->target, val); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_fixed(const avro_value_iface_t *iface, |
| void *vself, void *buf, size_t size) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_fixed(&self->target, buf, size); |
| } |
| |
| static int |
| avro_resolved_link_reader_give_fixed(const avro_value_iface_t *iface, |
| void *vself, avro_wrapped_buffer_t *buf) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_give_fixed(&self->target, buf); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_size(const avro_value_iface_t *iface, |
| const void *vself, size_t *size) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_size(&self->target, size); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_by_index(const avro_value_iface_t *iface, |
| const void *vself, size_t index, |
| avro_value_t *child, const char **name) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_by_index(&self->target, index, child, name); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_by_name(const avro_value_iface_t *iface, |
| const void *vself, const char *name, |
| avro_value_t *child, size_t *index) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_by_name(&self->target, name, child, index); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_discriminant(const avro_value_iface_t *iface, |
| const void *vself, int *out) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_discriminant(&self->target, out); |
| } |
| |
| static int |
| avro_resolved_link_reader_get_current_branch(const avro_value_iface_t *iface, |
| const void *vself, avro_value_t *branch) |
| { |
| AVRO_UNUSED(iface); |
| const avro_resolved_link_value_t *self = (const avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_get_current_branch(&self->target, branch); |
| } |
| |
| static int |
| avro_resolved_link_reader_append(const avro_value_iface_t *iface, |
| void *vself, avro_value_t *child_out, |
| size_t *new_index) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_append(&self->target, child_out, new_index); |
| } |
| |
| static int |
| avro_resolved_link_reader_add(const avro_value_iface_t *iface, |
| void *vself, const char *key, |
| avro_value_t *child, size_t *index, int *is_new) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_add(&self->target, key, child, index, is_new); |
| } |
| |
| static int |
| avro_resolved_link_reader_set_branch(const avro_value_iface_t *iface, |
| void *vself, int discriminant, |
| avro_value_t *branch) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_link_value_t *self = (avro_resolved_link_value_t *) vself; |
| avro_value_t *target_vself = (avro_value_t *) self->target.self; |
| *target_vself = self->wrapped; |
| return avro_value_set_branch(&self->target, discriminant, branch); |
| } |
| |
| static avro_resolved_link_reader_t * |
| avro_resolved_link_reader_create(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| avro_resolved_reader_t *self = (avro_resolved_reader_t *) avro_new(avro_resolved_link_reader_t); |
| memset(self, 0, sizeof(avro_resolved_link_reader_t)); |
| |
| self->parent.incref_iface = avro_resolved_reader_incref_iface; |
| self->parent.decref_iface = avro_resolved_reader_decref_iface; |
| self->parent.incref = avro_resolved_reader_incref; |
| self->parent.decref = avro_resolved_reader_decref; |
| self->parent.reset = avro_resolved_reader_reset; |
| self->parent.get_type = avro_resolved_link_reader_get_type; |
| self->parent.get_schema = avro_resolved_link_reader_get_schema; |
| self->parent.get_size = avro_resolved_link_reader_get_size; |
| self->parent.get_by_index = avro_resolved_link_reader_get_by_index; |
| self->parent.get_by_name = avro_resolved_link_reader_get_by_name; |
| |
| self->refcount = 1; |
| self->wschema = avro_schema_incref(wschema); |
| self->rschema = avro_schema_incref(rschema); |
| self->free_iface = avro_resolved_link_reader_free_iface; |
| self->init = avro_resolved_link_reader_init; |
| self->done = avro_resolved_link_reader_done; |
| self->reset_wrappers = avro_resolved_link_reader_reset; |
| |
| self->parent.get_boolean = avro_resolved_link_reader_get_boolean; |
| self->parent.get_bytes = avro_resolved_link_reader_get_bytes; |
| self->parent.grab_bytes = avro_resolved_link_reader_grab_bytes; |
| self->parent.get_double = avro_resolved_link_reader_get_double; |
| self->parent.get_float = avro_resolved_link_reader_get_float; |
| self->parent.get_int = avro_resolved_link_reader_get_int; |
| self->parent.get_long = avro_resolved_link_reader_get_long; |
| self->parent.get_null = avro_resolved_link_reader_get_null; |
| self->parent.get_string = avro_resolved_link_reader_get_string; |
| self->parent.grab_string = avro_resolved_link_reader_grab_string; |
| self->parent.get_enum = avro_resolved_link_reader_get_enum; |
| self->parent.get_fixed = avro_resolved_link_reader_get_fixed; |
| self->parent.grab_fixed = avro_resolved_link_reader_grab_fixed; |
| |
| self->parent.set_boolean = avro_resolved_link_reader_set_boolean; |
| self->parent.set_bytes = avro_resolved_link_reader_set_bytes; |
| self->parent.give_bytes = avro_resolved_link_reader_give_bytes; |
| self->parent.set_double = avro_resolved_link_reader_set_double; |
| self->parent.set_float = avro_resolved_link_reader_set_float; |
| self->parent.set_int = avro_resolved_link_reader_set_int; |
| self->parent.set_long = avro_resolved_link_reader_set_long; |
| self->parent.set_null = avro_resolved_link_reader_set_null; |
| self->parent.set_string = avro_resolved_link_reader_set_string; |
| self->parent.set_string_len = avro_resolved_link_reader_set_string_len; |
| self->parent.give_string_len = avro_resolved_link_reader_give_string_len; |
| self->parent.set_enum = avro_resolved_link_reader_set_enum; |
| self->parent.set_fixed = avro_resolved_link_reader_set_fixed; |
| self->parent.give_fixed = avro_resolved_link_reader_give_fixed; |
| |
| self->parent.get_size = avro_resolved_link_reader_get_size; |
| self->parent.get_by_index = avro_resolved_link_reader_get_by_index; |
| self->parent.get_by_name = avro_resolved_link_reader_get_by_name; |
| self->parent.get_discriminant = avro_resolved_link_reader_get_discriminant; |
| self->parent.get_current_branch = avro_resolved_link_reader_get_current_branch; |
| |
| self->parent.append = avro_resolved_link_reader_append; |
| self->parent.add = avro_resolved_link_reader_add; |
| self->parent.set_branch = avro_resolved_link_reader_set_branch; |
| |
| return container_of(self, avro_resolved_link_reader_t, parent); |
| } |
| |
| static avro_resolved_reader_t * |
| try_wlink(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| AVRO_UNUSED(rschema); |
| |
| /* |
| * For link schemas, we create a special value implementation |
| * that allocates space for its wrapped value at runtime. This |
| * lets us handle recursive types without having to instantiate |
| * in infinite-size value. |
| */ |
| |
| avro_schema_t wtarget = avro_schema_link_target(wschema); |
| avro_resolved_link_reader_t *lself = |
| avro_resolved_link_reader_create(wtarget, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, lself); |
| |
| avro_resolved_reader_t *target_resolver = |
| avro_resolved_reader_new_memoized(state, wtarget, rschema); |
| if (target_resolver == NULL) { |
| avro_memoize_delete(&state->mem, wschema, rschema); |
| avro_value_iface_decref(&lself->parent.parent); |
| avro_prefix_error("Link target isn't compatible: "); |
| DEBUG("%s", avro_strerror()); |
| return NULL; |
| } |
| |
| lself->parent.calculate_size = avro_resolved_wlink_reader_calculate_size; |
| lself->target_resolver = target_resolver; |
| lself->next = state->links; |
| state->links = lself; |
| |
| return &lself->parent; |
| } |
| |
| static avro_resolved_reader_t * |
| try_rlink(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| AVRO_UNUSED(rschema); |
| |
| /* |
| * For link schemas, we create a special value implementation |
| * that allocates space for its wrapped value at runtime. This |
| * lets us handle recursive types without having to instantiate |
| * in infinite-size value. |
| */ |
| |
| avro_schema_t rtarget = avro_schema_link_target(rschema); |
| avro_resolved_link_reader_t *lself = |
| avro_resolved_link_reader_create(wschema, rtarget); |
| avro_memoize_set(&state->mem, wschema, rschema, lself); |
| |
| avro_resolved_reader_t *target_resolver = |
| avro_resolved_reader_new_memoized(state, wschema, rtarget); |
| if (target_resolver == NULL) { |
| avro_memoize_delete(&state->mem, wschema, rschema); |
| avro_value_iface_decref(&lself->parent.parent); |
| avro_prefix_error("Link target isn't compatible: "); |
| DEBUG("%s", avro_strerror()); |
| return NULL; |
| } |
| |
| lself->parent.calculate_size = avro_resolved_rlink_reader_calculate_size; |
| lself->target_resolver = target_resolver; |
| lself->next = state->links; |
| state->links = lself; |
| |
| return &lself->parent; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * boolean |
| */ |
| |
| static int |
| avro_resolved_reader_get_boolean(const avro_value_iface_t *viface, |
| const void *vself, int *val) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting boolean from %p", src->self); |
| return avro_value_get_boolean(src, val); |
| } |
| |
| static avro_resolved_reader_t * |
| try_boolean(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_boolean(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_boolean = avro_resolved_reader_get_boolean; |
| return self; |
| } |
| avro_set_error("Writer %s not compatible with reader boolean", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * bytes |
| */ |
| |
| static int |
| avro_resolved_reader_get_bytes(const avro_value_iface_t *viface, |
| const void *vself, const void **buf, size_t *size) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting bytes from %p", src->self); |
| return avro_value_get_bytes(src, buf, size); |
| } |
| |
| static int |
| avro_resolved_reader_grab_bytes(const avro_value_iface_t *viface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Grabbing bytes from %p", src->self); |
| return avro_value_grab_bytes(src, dest); |
| } |
| |
| static avro_resolved_reader_t * |
| try_bytes(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_bytes(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_bytes = avro_resolved_reader_get_bytes; |
| self->parent.grab_bytes = avro_resolved_reader_grab_bytes; |
| return self; |
| } |
| avro_set_error("Writer %s not compatible with reader bytes", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * double |
| */ |
| |
| static int |
| avro_resolved_reader_get_double(const avro_value_iface_t *viface, |
| const void *vself, double *val) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting double from %p", src->self); |
| return avro_value_get_double(src, val); |
| } |
| |
| static int |
| avro_resolved_reader_get_double_float(const avro_value_iface_t *viface, |
| const void *vself, double *val) |
| { |
| int rval; |
| float real_val; |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Promoting double from float %p", src->self); |
| check(rval, avro_value_get_float(src, &real_val)); |
| *val = real_val; |
| return 0; |
| } |
| |
| static int |
| avro_resolved_reader_get_double_int(const avro_value_iface_t *viface, |
| const void *vself, double *val) |
| { |
| int rval; |
| int32_t real_val; |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Promoting double from int %p", src->self); |
| check(rval, avro_value_get_int(src, &real_val)); |
| *val = real_val; |
| return 0; |
| } |
| |
| static int |
| avro_resolved_reader_get_double_long(const avro_value_iface_t *viface, |
| const void *vself, double *val) |
| { |
| int rval; |
| int64_t real_val; |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Promoting double from long %p", src->self); |
| check(rval, avro_value_get_long(src, &real_val)); |
| *val = (double) real_val; |
| return 0; |
| } |
| |
| static avro_resolved_reader_t * |
| try_double(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_double(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_double = avro_resolved_reader_get_double; |
| return self; |
| } |
| |
| else if (is_avro_float(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_double = avro_resolved_reader_get_double_float; |
| return self; |
| } |
| |
| else if (is_avro_int32(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_double = avro_resolved_reader_get_double_int; |
| return self; |
| } |
| |
| else if (is_avro_int64(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_double = avro_resolved_reader_get_double_long; |
| return self; |
| } |
| |
| avro_set_error("Writer %s not compatible with reader double", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * float |
| */ |
| |
| static int |
| avro_resolved_reader_get_float(const avro_value_iface_t *viface, |
| const void *vself, float *val) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting float from %p", src->self); |
| return avro_value_get_float(src, val); |
| } |
| |
| static int |
| avro_resolved_reader_get_float_int(const avro_value_iface_t *viface, |
| const void *vself, float *val) |
| { |
| int rval; |
| int32_t real_val; |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Promoting float from int %p", src->self); |
| check(rval, avro_value_get_int(src, &real_val)); |
| *val = (float) real_val; |
| return 0; |
| } |
| |
| static int |
| avro_resolved_reader_get_float_long(const avro_value_iface_t *viface, |
| const void *vself, float *val) |
| { |
| int rval; |
| int64_t real_val; |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Promoting float from long %p", src->self); |
| check(rval, avro_value_get_long(src, &real_val)); |
| *val = (float) real_val; |
| return 0; |
| } |
| |
| static avro_resolved_reader_t * |
| try_float(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_float(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_float = avro_resolved_reader_get_float; |
| return self; |
| } |
| |
| else if (is_avro_int32(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_float = avro_resolved_reader_get_float_int; |
| return self; |
| } |
| |
| else if (is_avro_int64(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_float = avro_resolved_reader_get_float_long; |
| return self; |
| } |
| |
| avro_set_error("Writer %s not compatible with reader float", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * int |
| */ |
| |
| static int |
| avro_resolved_reader_get_int(const avro_value_iface_t *viface, |
| const void *vself, int32_t *val) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting int from %p", src->self); |
| return avro_value_get_int(src, val); |
| } |
| |
| static avro_resolved_reader_t * |
| try_int(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_int32(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_int = avro_resolved_reader_get_int; |
| return self; |
| } |
| avro_set_error("Writer %s not compatible with reader int", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * long |
| */ |
| |
| static int |
| avro_resolved_reader_get_long(const avro_value_iface_t *viface, |
| const void *vself, int64_t *val) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting long from %p", src->self); |
| return avro_value_get_long(src, val); |
| } |
| |
| static int |
| avro_resolved_reader_get_long_int(const avro_value_iface_t *viface, |
| const void *vself, int64_t *val) |
| { |
| int rval; |
| int32_t real_val; |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Promoting long from int %p", src->self); |
| check(rval, avro_value_get_int(src, &real_val)); |
| *val = real_val; |
| return 0; |
| } |
| |
| static avro_resolved_reader_t * |
| try_long(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_int64(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_long = avro_resolved_reader_get_long; |
| return self; |
| } |
| |
| else if (is_avro_int32(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_long = avro_resolved_reader_get_long_int; |
| return self; |
| } |
| |
| avro_set_error("Writer %s not compatible with reader long", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * null |
| */ |
| |
| static int |
| avro_resolved_reader_get_null(const avro_value_iface_t *viface, |
| const void *vself) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting null from %p", src->self); |
| return avro_value_get_null(src); |
| } |
| |
| static avro_resolved_reader_t * |
| try_null(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_null(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_null = avro_resolved_reader_get_null; |
| return self; |
| } |
| avro_set_error("Writer %s not compatible with reader null", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * string |
| */ |
| |
| static int |
| avro_resolved_reader_get_string(const avro_value_iface_t *viface, |
| const void *vself, const char **str, size_t *size) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting string from %p", src->self); |
| return avro_value_get_string(src, str, size); |
| } |
| |
| static int |
| avro_resolved_reader_grab_string(const avro_value_iface_t *viface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Grabbing string from %p", src->self); |
| return avro_value_grab_string(src, dest); |
| } |
| |
| static avro_resolved_reader_t * |
| try_string(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| if (is_avro_string(wschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_string = avro_resolved_reader_get_string; |
| self->parent.grab_string = avro_resolved_reader_grab_string; |
| return self; |
| } |
| avro_set_error("Writer %s not compatible with reader string", |
| avro_schema_type_name(wschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * array |
| */ |
| |
| typedef struct avro_resolved_array_reader { |
| avro_resolved_reader_t parent; |
| avro_resolved_reader_t *child_resolver; |
| } avro_resolved_array_reader_t; |
| |
| typedef struct avro_resolved_array_value { |
| avro_value_t wrapped; |
| avro_raw_array_t children; |
| } avro_resolved_array_value_t; |
| |
| static void |
| avro_resolved_array_reader_calculate_size(avro_resolved_reader_t *iface) |
| { |
| avro_resolved_array_reader_t *aiface = |
| container_of(iface, avro_resolved_array_reader_t, parent); |
| |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for %s->%s", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| iface->instance_size = sizeof(avro_resolved_array_value_t); |
| |
| avro_resolved_reader_calculate_size(aiface->child_resolver); |
| } |
| |
| static void |
| avro_resolved_array_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| avro_resolved_array_reader_t *aiface = |
| container_of(iface, avro_resolved_array_reader_t, parent); |
| free_resolver(aiface->child_resolver, freeing); |
| avro_schema_decref(iface->wschema); |
| avro_schema_decref(iface->rschema); |
| avro_freet(avro_resolved_array_reader_t, iface); |
| } |
| |
| static int |
| avro_resolved_array_reader_init(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_array_reader_t *aiface = |
| container_of(iface, avro_resolved_array_reader_t, parent); |
| avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself; |
| size_t child_instance_size = aiface->child_resolver->instance_size; |
| DEBUG("Initializing child array (child_size=%" PRIsz ")", child_instance_size); |
| avro_raw_array_init(&self->children, child_instance_size); |
| return 0; |
| } |
| |
| static void |
| avro_resolved_array_reader_free_elements(const avro_resolved_reader_t *child_iface, |
| avro_resolved_array_value_t *self) |
| { |
| size_t i; |
| for (i = 0; i < avro_raw_array_size(&self->children); i++) { |
| void *child_self = avro_raw_array_get_raw(&self->children, i); |
| avro_resolved_reader_done(child_iface, child_self); |
| } |
| } |
| |
| static void |
| avro_resolved_array_reader_done(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_array_reader_t *aiface = |
| container_of(iface, avro_resolved_array_reader_t, parent); |
| avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself; |
| avro_resolved_array_reader_free_elements(aiface->child_resolver, self); |
| avro_raw_array_done(&self->children); |
| } |
| |
| static int |
| avro_resolved_array_reader_reset(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_array_reader_t *aiface = |
| container_of(iface, avro_resolved_array_reader_t, parent); |
| avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself; |
| |
| /* Clear out our cache of wrapped children */ |
| avro_resolved_array_reader_free_elements(aiface->child_resolver, self); |
| avro_raw_array_clear(&self->children); |
| return 0; |
| } |
| |
| static int |
| avro_resolved_array_reader_get_size(const avro_value_iface_t *viface, |
| const void *vself, size_t *size) |
| { |
| AVRO_UNUSED(viface); |
| const avro_resolved_array_value_t *self = (const avro_resolved_array_value_t *) vself; |
| return avro_value_get_size(&self->wrapped, size); |
| } |
| |
| static int |
| avro_resolved_array_reader_get_by_index(const avro_value_iface_t *viface, |
| const void *vself, size_t index, |
| avro_value_t *child, const char **name) |
| { |
| int rval; |
| size_t old_size; |
| size_t new_size; |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_array_reader_t *aiface = |
| container_of(iface, avro_resolved_array_reader_t, parent); |
| avro_resolved_array_value_t *self = (avro_resolved_array_value_t *) vself; |
| |
| /* |
| * Ensure that our child wrapper array is big enough to hold |
| * this many elements. |
| */ |
| new_size = index + 1; |
| check(rval, avro_raw_array_ensure_size0(&self->children, new_size)); |
| old_size = avro_raw_array_size(&self->children); |
| if (old_size <= index) { |
| size_t i; |
| for (i = old_size; i < new_size; i++) { |
| check(rval, avro_resolved_reader_init |
| (aiface->child_resolver, |
| avro_raw_array_get_raw(&self->children, i))); |
| } |
| avro_raw_array_size(&self->children) = index+1; |
| } |
| |
| child->iface = &aiface->child_resolver->parent; |
| child->self = avro_raw_array_get_raw(&self->children, index); |
| |
| DEBUG("Getting element %" PRIsz " from array %p", index, self->wrapped.self); |
| return avro_value_get_by_index(&self->wrapped, index, (avro_value_t *) child->self, name); |
| } |
| |
| static avro_resolved_array_reader_t * |
| avro_resolved_array_reader_create(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| avro_resolved_reader_t *self = (avro_resolved_reader_t *) avro_new(avro_resolved_array_reader_t); |
| memset(self, 0, sizeof(avro_resolved_array_reader_t)); |
| |
| self->parent.incref_iface = avro_resolved_reader_incref_iface; |
| self->parent.decref_iface = avro_resolved_reader_decref_iface; |
| self->parent.incref = avro_resolved_reader_incref; |
| self->parent.decref = avro_resolved_reader_decref; |
| self->parent.reset = avro_resolved_reader_reset; |
| self->parent.get_type = avro_resolved_reader_get_type; |
| self->parent.get_schema = avro_resolved_reader_get_schema; |
| self->parent.get_size = avro_resolved_array_reader_get_size; |
| self->parent.get_by_index = avro_resolved_array_reader_get_by_index; |
| |
| self->refcount = 1; |
| self->wschema = avro_schema_incref(wschema); |
| self->rschema = avro_schema_incref(rschema); |
| self->calculate_size = avro_resolved_array_reader_calculate_size; |
| self->free_iface = avro_resolved_array_reader_free_iface; |
| self->init = avro_resolved_array_reader_init; |
| self->done = avro_resolved_array_reader_done; |
| self->reset_wrappers = avro_resolved_array_reader_reset; |
| return container_of(self, avro_resolved_array_reader_t, parent); |
| } |
| |
| static avro_resolved_reader_t * |
| try_array(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * First verify that the writer is an array. |
| */ |
| |
| if (!is_avro_array(wschema)) { |
| return 0; |
| } |
| |
| /* |
| * Array schemas have to have compatible element schemas to be |
| * compatible themselves. Try to create an resolver to check |
| * the compatibility. |
| */ |
| |
| avro_resolved_array_reader_t *aself = |
| avro_resolved_array_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, aself); |
| |
| avro_schema_t witems = avro_schema_array_items(wschema); |
| avro_schema_t ritems = avro_schema_array_items(rschema); |
| |
| avro_resolved_reader_t *item_resolver = |
| avro_resolved_reader_new_memoized(state, witems, ritems); |
| if (item_resolver == NULL) { |
| avro_memoize_delete(&state->mem, wschema, rschema); |
| avro_value_iface_decref(&aself->parent.parent); |
| avro_prefix_error("Array values aren't compatible: "); |
| return NULL; |
| } |
| |
| /* |
| * The two schemas are compatible. Store the item schema's |
| * resolver into the child_resolver field. |
| */ |
| |
| aself->child_resolver = item_resolver; |
| return &aself->parent; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * enum |
| */ |
| |
| static int |
| avro_resolved_reader_get_enum(const avro_value_iface_t *viface, |
| const void *vself, int *val) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting enum from %p", src->self); |
| return avro_value_get_enum(src, val); |
| } |
| |
| static avro_resolved_reader_t * |
| try_enum(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * Enum schemas have to have the same name — but not the same |
| * list of symbols — to be compatible. |
| */ |
| |
| if (is_avro_enum(wschema)) { |
| const char *wname = avro_schema_name(wschema); |
| const char *rname = avro_schema_name(rschema); |
| |
| if (strcmp(wname, rname) == 0) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_enum = avro_resolved_reader_get_enum; |
| return self; |
| } |
| } |
| avro_set_error("Writer %s not compatible with reader %s", |
| avro_schema_type_name(wschema), |
| avro_schema_type_name(rschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * fixed |
| */ |
| |
| static int |
| avro_resolved_reader_get_fixed(const avro_value_iface_t *viface, |
| const void *vself, const void **buf, size_t *size) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Getting fixed from %p", vself); |
| return avro_value_get_fixed(src, buf, size); |
| } |
| |
| static int |
| avro_resolved_reader_grab_fixed(const avro_value_iface_t *viface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| DEBUG("Grabbing fixed from %p", vself); |
| return avro_value_grab_fixed(src, dest); |
| } |
| |
| static avro_resolved_reader_t * |
| try_fixed(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * Fixed schemas need the same name and size to be compatible. |
| */ |
| |
| if (avro_schema_equal(wschema, rschema)) { |
| avro_resolved_reader_t *self = |
| avro_resolved_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, self); |
| self->parent.get_fixed = avro_resolved_reader_get_fixed; |
| self->parent.grab_fixed = avro_resolved_reader_grab_fixed; |
| return self; |
| } |
| avro_set_error("Writer %s not compatible with reader %s", |
| avro_schema_type_name(wschema), |
| avro_schema_type_name(rschema)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * map |
| */ |
| |
| typedef struct avro_resolved_map_reader { |
| avro_resolved_reader_t parent; |
| avro_resolved_reader_t *child_resolver; |
| } avro_resolved_map_reader_t; |
| |
| typedef struct avro_resolved_map_value { |
| avro_value_t wrapped; |
| avro_raw_array_t children; |
| } avro_resolved_map_value_t; |
| |
| static void |
| avro_resolved_map_reader_calculate_size(avro_resolved_reader_t *iface) |
| { |
| avro_resolved_map_reader_t *miface = |
| container_of(iface, avro_resolved_map_reader_t, parent); |
| |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for %s->%s", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| iface->instance_size = sizeof(avro_resolved_map_value_t); |
| |
| avro_resolved_reader_calculate_size(miface->child_resolver); |
| } |
| |
| static void |
| avro_resolved_map_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| avro_resolved_map_reader_t *miface = |
| container_of(iface, avro_resolved_map_reader_t, parent); |
| free_resolver(miface->child_resolver, freeing); |
| avro_schema_decref(iface->wschema); |
| avro_schema_decref(iface->rschema); |
| avro_freet(avro_resolved_map_reader_t, iface); |
| } |
| |
| static int |
| avro_resolved_map_reader_init(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_map_reader_t *miface = |
| container_of(iface, avro_resolved_map_reader_t, parent); |
| avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself; |
| size_t child_instance_size = miface->child_resolver->instance_size; |
| DEBUG("Initializing child array for map (child_size=%" PRIsz ")", child_instance_size); |
| avro_raw_array_init(&self->children, child_instance_size); |
| return 0; |
| } |
| |
| static void |
| avro_resolved_map_reader_free_elements(const avro_resolved_reader_t *child_iface, |
| avro_resolved_map_value_t *self) |
| { |
| size_t i; |
| for (i = 0; i < avro_raw_array_size(&self->children); i++) { |
| void *child_self = avro_raw_array_get_raw(&self->children, i); |
| avro_resolved_reader_done(child_iface, child_self); |
| } |
| } |
| |
| static void |
| avro_resolved_map_reader_done(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_map_reader_t *miface = |
| container_of(iface, avro_resolved_map_reader_t, parent); |
| avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself; |
| avro_resolved_map_reader_free_elements(miface->child_resolver, self); |
| avro_raw_array_done(&self->children); |
| } |
| |
| static int |
| avro_resolved_map_reader_reset(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_map_reader_t *miface = |
| container_of(iface, avro_resolved_map_reader_t, parent); |
| avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself; |
| |
| /* Clear out our cache of wrapped children */ |
| avro_resolved_map_reader_free_elements(miface->child_resolver, self); |
| return 0; |
| } |
| |
| static int |
| avro_resolved_map_reader_get_size(const avro_value_iface_t *viface, |
| const void *vself, size_t *size) |
| { |
| AVRO_UNUSED(viface); |
| const avro_value_t *src = (const avro_value_t *) vself; |
| return avro_value_get_size(src, size); |
| } |
| |
| static int |
| avro_resolved_map_reader_get_by_index(const avro_value_iface_t *viface, |
| const void *vself, size_t index, |
| avro_value_t *child, const char **name) |
| { |
| int rval; |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_map_reader_t *miface = |
| container_of(iface, avro_resolved_map_reader_t, parent); |
| avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself; |
| |
| /* |
| * Ensure that our child wrapper array is big enough to hold |
| * this many elements. |
| */ |
| check(rval, avro_raw_array_ensure_size0(&self->children, index+1)); |
| if (avro_raw_array_size(&self->children) <= index) { |
| avro_raw_array_size(&self->children) = index+1; |
| } |
| |
| child->iface = &miface->child_resolver->parent; |
| child->self = avro_raw_array_get_raw(&self->children, index); |
| |
| DEBUG("Getting element %" PRIsz " from map %p", index, self->wrapped.self); |
| return avro_value_get_by_index(&self->wrapped, index, (avro_value_t *) child->self, name); |
| } |
| |
| static int |
| avro_resolved_map_reader_get_by_name(const avro_value_iface_t *viface, |
| const void *vself, const char *name, |
| avro_value_t *child, size_t *index) |
| { |
| int rval; |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_map_reader_t *miface = |
| container_of(iface, avro_resolved_map_reader_t, parent); |
| avro_resolved_map_value_t *self = (avro_resolved_map_value_t *) vself; |
| |
| /* |
| * This is a bit convoluted. We need to stash the wrapped child |
| * value somewhere in our children array. But we don't know |
| * where to put it until the wrapped map tells us what its index |
| * is. |
| */ |
| |
| avro_value_t real_child; |
| size_t real_index; |
| |
| DEBUG("Getting element %s from map %p", name, self->wrapped.self); |
| check(rval, avro_value_get_by_name |
| (&self->wrapped, name, &real_child, &real_index)); |
| |
| /* |
| * Ensure that our child wrapper array is big enough to hold |
| * this many elements. |
| */ |
| check(rval, avro_raw_array_ensure_size0(&self->children, real_index+1)); |
| if (avro_raw_array_size(&self->children) <= real_index) { |
| avro_raw_array_size(&self->children) = real_index+1; |
| } |
| |
| child->iface = &miface->child_resolver->parent; |
| child->self = avro_raw_array_get_raw(&self->children, real_index); |
| avro_value_t *child_vself = (avro_value_t *) child->self; |
| *child_vself = real_child; |
| |
| if (index != NULL) { |
| *index = real_index; |
| } |
| return 0; |
| } |
| |
| static avro_resolved_map_reader_t * |
| avro_resolved_map_reader_create(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| avro_resolved_reader_t *self = (avro_resolved_reader_t *) avro_new(avro_resolved_map_reader_t); |
| memset(self, 0, sizeof(avro_resolved_map_reader_t)); |
| |
| self->parent.incref_iface = avro_resolved_reader_incref_iface; |
| self->parent.decref_iface = avro_resolved_reader_decref_iface; |
| self->parent.incref = avro_resolved_reader_incref; |
| self->parent.decref = avro_resolved_reader_decref; |
| self->parent.reset = avro_resolved_reader_reset; |
| self->parent.get_type = avro_resolved_reader_get_type; |
| self->parent.get_schema = avro_resolved_reader_get_schema; |
| self->parent.get_size = avro_resolved_map_reader_get_size; |
| self->parent.get_by_index = avro_resolved_map_reader_get_by_index; |
| self->parent.get_by_name = avro_resolved_map_reader_get_by_name; |
| |
| self->refcount = 1; |
| self->wschema = avro_schema_incref(wschema); |
| self->rschema = avro_schema_incref(rschema); |
| self->calculate_size = avro_resolved_map_reader_calculate_size; |
| self->free_iface = avro_resolved_map_reader_free_iface; |
| self->init = avro_resolved_map_reader_init; |
| self->done = avro_resolved_map_reader_done; |
| self->reset_wrappers = avro_resolved_map_reader_reset; |
| return container_of(self, avro_resolved_map_reader_t, parent); |
| } |
| |
| static avro_resolved_reader_t * |
| try_map(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * First verify that the reader is an map. |
| */ |
| |
| if (!is_avro_map(wschema)) { |
| return 0; |
| } |
| |
| /* |
| * Map schemas have to have compatible element schemas to be |
| * compatible themselves. Try to create an resolver to check |
| * the compatibility. |
| */ |
| |
| avro_resolved_map_reader_t *mself = |
| avro_resolved_map_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, mself); |
| |
| avro_schema_t witems = avro_schema_map_values(wschema); |
| avro_schema_t ritems = avro_schema_map_values(rschema); |
| |
| avro_resolved_reader_t *item_resolver = |
| avro_resolved_reader_new_memoized(state, witems, ritems); |
| if (item_resolver == NULL) { |
| avro_memoize_delete(&state->mem, wschema, rschema); |
| avro_value_iface_decref(&mself->parent.parent); |
| avro_prefix_error("Map values aren't compatible: "); |
| return NULL; |
| } |
| |
| /* |
| * The two schemas are compatible. Store the item schema's |
| * resolver into the child_resolver field. |
| */ |
| |
| mself->child_resolver = item_resolver; |
| return &mself->parent; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * record |
| */ |
| |
| typedef struct avro_resolved_record_reader { |
| avro_resolved_reader_t parent; |
| size_t field_count; |
| size_t *field_offsets; |
| avro_resolved_reader_t **field_resolvers; |
| size_t *index_mapping; |
| } avro_resolved_record_reader_t; |
| |
| typedef struct avro_resolved_record_value { |
| avro_value_t wrapped; |
| /* The rest of the struct is taken up by the inline storage |
| * needed for each field. */ |
| } avro_resolved_record_value_t; |
| |
| /** Return a pointer to the given field within a record struct. */ |
| #define avro_resolved_record_field(iface, rec, index) \ |
| (((char *) (rec)) + (iface)->field_offsets[(index)]) |
| |
| |
| static void |
| avro_resolved_record_reader_calculate_size(avro_resolved_reader_t *iface) |
| { |
| avro_resolved_record_reader_t *riface = |
| container_of(iface, avro_resolved_record_reader_t, parent); |
| |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for %s->%s", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| |
| /* |
| * Once we've figured out which reader fields we actually need, |
| * calculate an offset for each one. |
| */ |
| |
| size_t ri; |
| size_t next_offset = sizeof(avro_resolved_record_value_t); |
| for (ri = 0; ri < riface->field_count; ri++) { |
| riface->field_offsets[ri] = next_offset; |
| if (riface->field_resolvers[ri] != NULL) { |
| avro_resolved_reader_calculate_size |
| (riface->field_resolvers[ri]); |
| size_t field_size = |
| riface->field_resolvers[ri]->instance_size; |
| DEBUG("Field %" PRIsz " has size %" PRIsz, ri, field_size); |
| next_offset += field_size; |
| } else { |
| DEBUG("Field %" PRIsz " is being skipped", ri); |
| } |
| } |
| |
| DEBUG("Record has size %" PRIsz, next_offset); |
| iface->instance_size = next_offset; |
| } |
| |
| |
| static void |
| avro_resolved_record_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| avro_resolved_record_reader_t *riface = |
| container_of(iface, avro_resolved_record_reader_t, parent); |
| |
| if (riface->field_offsets != NULL) { |
| avro_free(riface->field_offsets, |
| riface->field_count * sizeof(size_t)); |
| } |
| |
| if (riface->field_resolvers != NULL) { |
| size_t i; |
| for (i = 0; i < riface->field_count; i++) { |
| if (riface->field_resolvers[i] != NULL) { |
| DEBUG("Freeing field %" PRIsz " %p", i, |
| riface->field_resolvers[i]); |
| free_resolver(riface->field_resolvers[i], freeing); |
| } |
| } |
| avro_free(riface->field_resolvers, |
| riface->field_count * sizeof(avro_resolved_reader_t *)); |
| } |
| |
| if (riface->index_mapping != NULL) { |
| avro_free(riface->index_mapping, |
| riface->field_count * sizeof(size_t)); |
| } |
| |
| avro_schema_decref(iface->wschema); |
| avro_schema_decref(iface->rschema); |
| avro_freet(avro_resolved_record_reader_t, iface); |
| } |
| |
| static int |
| avro_resolved_record_reader_init(const avro_resolved_reader_t *iface, void *vself) |
| { |
| int rval; |
| const avro_resolved_record_reader_t *riface = |
| container_of(iface, avro_resolved_record_reader_t, parent); |
| avro_resolved_record_value_t *self = (avro_resolved_record_value_t *) vself; |
| |
| /* Initialize each field */ |
| size_t i; |
| for (i = 0; i < riface->field_count; i++) { |
| if (riface->field_resolvers[i] != NULL) { |
| check(rval, avro_resolved_reader_init |
| (riface->field_resolvers[i], |
| avro_resolved_record_field(riface, self, i))); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static void |
| avro_resolved_record_reader_done(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_record_reader_t *riface = |
| container_of(iface, avro_resolved_record_reader_t, parent); |
| avro_resolved_record_value_t *self = (avro_resolved_record_value_t *) vself; |
| |
| /* Finalize each field */ |
| size_t i; |
| for (i = 0; i < riface->field_count; i++) { |
| if (riface->field_resolvers[i] != NULL) { |
| avro_resolved_reader_done |
| (riface->field_resolvers[i], |
| avro_resolved_record_field(riface, self, i)); |
| } |
| } |
| } |
| |
| static int |
| avro_resolved_record_reader_reset(const avro_resolved_reader_t *iface, void *vself) |
| { |
| int rval; |
| const avro_resolved_record_reader_t *riface = |
| container_of(iface, avro_resolved_record_reader_t, parent); |
| avro_resolved_record_value_t *self = (avro_resolved_record_value_t *) vself; |
| |
| /* Reset each field */ |
| size_t i; |
| for (i = 0; i < riface->field_count; i++) { |
| if (riface->field_resolvers[i] != NULL) { |
| check(rval, avro_resolved_reader_reset_wrappers |
| (riface->field_resolvers[i], |
| avro_resolved_record_field(riface, self, i))); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int |
| avro_resolved_record_reader_get_size(const avro_value_iface_t *viface, |
| const void *vself, size_t *size) |
| { |
| AVRO_UNUSED(vself); |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_record_reader_t *riface = |
| container_of(iface, avro_resolved_record_reader_t, parent); |
| *size = riface->field_count; |
| return 0; |
| } |
| |
| static int |
| avro_resolved_record_reader_get_by_index(const avro_value_iface_t *viface, |
| const void *vself, size_t index, |
| avro_value_t *child, const char **name) |
| { |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_record_reader_t *riface = |
| container_of(iface, avro_resolved_record_reader_t, parent); |
| const avro_resolved_record_value_t *self = (avro_resolved_record_value_t *) vself; |
| |
| DEBUG("Getting reader field %" PRIsz " from record %p", index, self->wrapped.self); |
| if (riface->field_resolvers[index] == NULL) { |
| /* |
| * TODO: Return the default value if the writer record |
| * doesn't contain this field. |
| */ |
| DEBUG("Writer doesn't have field"); |
| avro_set_error("NIY: Default values"); |
| return EINVAL; |
| } |
| |
| size_t writer_index = riface->index_mapping[index]; |
| DEBUG(" Writer field is %" PRIsz, writer_index); |
| child->iface = &riface->field_resolvers[index]->parent; |
| child->self = avro_resolved_record_field(riface, self, index); |
| return avro_value_get_by_index(&self->wrapped, writer_index, (avro_value_t *) child->self, name); |
| } |
| |
| static int |
| avro_resolved_record_reader_get_by_name(const avro_value_iface_t *viface, |
| const void *vself, const char *name, |
| avro_value_t *child, size_t *index) |
| { |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| |
| int ri = avro_schema_record_field_get_index(iface->rschema, name); |
| if (ri == -1) { |
| avro_set_error("Record doesn't have field named %s", name); |
| return EINVAL; |
| } |
| |
| DEBUG("Reader field %s is at index %d", name, ri); |
| if (index != NULL) { |
| *index = ri; |
| } |
| return avro_resolved_record_reader_get_by_index(viface, vself, ri, child, NULL); |
| } |
| |
| static avro_resolved_record_reader_t * |
| avro_resolved_record_reader_create(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| avro_resolved_reader_t *self = (avro_resolved_reader_t *) avro_new(avro_resolved_record_reader_t); |
| memset(self, 0, sizeof(avro_resolved_record_reader_t)); |
| |
| self->parent.incref_iface = avro_resolved_reader_incref_iface; |
| self->parent.decref_iface = avro_resolved_reader_decref_iface; |
| self->parent.incref = avro_resolved_reader_incref; |
| self->parent.decref = avro_resolved_reader_decref; |
| self->parent.reset = avro_resolved_reader_reset; |
| self->parent.get_type = avro_resolved_reader_get_type; |
| self->parent.get_schema = avro_resolved_reader_get_schema; |
| self->parent.get_size = avro_resolved_record_reader_get_size; |
| self->parent.get_by_index = avro_resolved_record_reader_get_by_index; |
| self->parent.get_by_name = avro_resolved_record_reader_get_by_name; |
| |
| self->refcount = 1; |
| self->wschema = avro_schema_incref(wschema); |
| self->rschema = avro_schema_incref(rschema); |
| self->calculate_size = avro_resolved_record_reader_calculate_size; |
| self->free_iface = avro_resolved_record_reader_free_iface; |
| self->init = avro_resolved_record_reader_init; |
| self->done = avro_resolved_record_reader_done; |
| self->reset_wrappers = avro_resolved_record_reader_reset; |
| return container_of(self, avro_resolved_record_reader_t, parent); |
| } |
| |
| static avro_resolved_reader_t * |
| try_record(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * First verify that the writer is also a record, and has the |
| * same name as the reader. |
| */ |
| |
| if (!is_avro_record(wschema)) { |
| return 0; |
| } |
| |
| const char *wname = avro_schema_name(wschema); |
| const char *rname = avro_schema_name(rschema); |
| |
| if (strcmp(wname, rname) != 0) { |
| return 0; |
| } |
| |
| /* |
| * Categorize the fields in the record schemas. Fields that are |
| * only in the writer are ignored. Fields that are only in the |
| * reader raise a schema mismatch error, unless the field has a |
| * default value. Fields that are in both are resolved |
| * recursively. |
| * |
| * The field_resolvers array will contain an avro_value_iface_t |
| * for each field in the reader schema. To build this array, we |
| * loop through the fields of the reader schema. If that field |
| * is also in the writer schema, we resolve them recursively, |
| * and store the resolver into the array. If the field isn't in |
| * the writer schema, we raise an error. (TODO: Eventually, |
| * we'll handle default values here.) After this loop finishes, |
| * any NULLs in the field_resolvers array will represent fields |
| * in the writer but not the reader; these fields should be |
| * skipped, and won't be accessible in the resolved reader. |
| */ |
| |
| avro_resolved_record_reader_t *rself = |
| avro_resolved_record_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, rself); |
| |
| size_t rfields = avro_schema_record_size(rschema); |
| |
| DEBUG("Checking reader record schema %s", wname); |
| |
| avro_resolved_reader_t **field_resolvers = |
| (avro_resolved_reader_t **) avro_calloc(rfields, sizeof(avro_resolved_reader_t *)); |
| size_t *field_offsets = (size_t *) avro_calloc(rfields, sizeof(size_t)); |
| size_t *index_mapping = (size_t *) avro_calloc(rfields, sizeof(size_t)); |
| |
| size_t ri; |
| for (ri = 0; ri < rfields; ri++) { |
| avro_schema_t rfield = |
| avro_schema_record_field_get_by_index(rschema, ri); |
| const char *field_name = |
| avro_schema_record_field_name(rschema, ri); |
| |
| DEBUG("Resolving reader record field %" PRIsz " (%s)", ri, field_name); |
| |
| /* |
| * See if this field is also in the writer schema. |
| */ |
| |
| int wi = avro_schema_record_field_get_index(wschema, field_name); |
| |
| if (wi == -1) { |
| /* |
| * This field isn't in the writer schema — |
| * that's an error! TODO: Handle default |
| * values! |
| */ |
| |
| DEBUG("Field %s isn't in writer", field_name); |
| avro_set_error("Reader field %s doesn't appear in writer", |
| field_name); |
| goto error; |
| } |
| |
| /* |
| * Try to recursively resolve the schemas for this |
| * field. If they're not compatible, that's an error. |
| */ |
| |
| avro_schema_t wfield = |
| avro_schema_record_field_get_by_index(wschema, wi); |
| avro_resolved_reader_t *field_resolver = |
| avro_resolved_reader_new_memoized(state, wfield, rfield); |
| |
| if (field_resolver == NULL) { |
| avro_prefix_error("Field %s isn't compatible: ", field_name); |
| goto error; |
| } |
| |
| /* |
| * Save the details for this field. |
| */ |
| |
| DEBUG("Found match for field %s (%" PRIsz " in reader, %d in writer)", |
| field_name, ri, wi); |
| field_resolvers[ri] = field_resolver; |
| index_mapping[ri] = wi; |
| } |
| |
| /* |
| * We might not have found matches for all of the writer fields, |
| * but that's okay — any extras will be ignored. |
| */ |
| |
| rself->field_count = rfields; |
| rself->field_offsets = field_offsets; |
| rself->field_resolvers = field_resolvers; |
| rself->index_mapping = index_mapping; |
| return &rself->parent; |
| |
| error: |
| /* |
| * Clean up any resolver we might have already created. |
| */ |
| |
| avro_memoize_delete(&state->mem, wschema, rschema); |
| avro_value_iface_decref(&rself->parent.parent); |
| |
| { |
| unsigned int i; |
| for (i = 0; i < rfields; i++) { |
| if (field_resolvers[i]) { |
| avro_value_iface_decref(&field_resolvers[i]->parent); |
| } |
| } |
| } |
| |
| avro_free(field_resolvers, rfields * sizeof(avro_resolved_reader_t *)); |
| avro_free(field_offsets, rfields * sizeof(size_t)); |
| avro_free(index_mapping, rfields * sizeof(size_t)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * writer union |
| */ |
| |
| /* |
| * For writer unions, we maintain a list of resolvers for each branch of |
| * the union. When we encounter a writer value, we see which branch it |
| * is, and choose a reader resolver based on that. |
| */ |
| |
| typedef struct avro_resolved_wunion_reader { |
| avro_resolved_reader_t parent; |
| |
| /* The number of branches in the writer union */ |
| size_t branch_count; |
| |
| /* A child resolver for each branch of the writer union. If any |
| * of these are NULL, then we don't have anything on the reader |
| * side that's compatible with that writer branch. */ |
| avro_resolved_reader_t **branch_resolvers; |
| |
| } avro_resolved_wunion_reader_t; |
| |
| typedef struct avro_resolved_wunion_value { |
| avro_value_t wrapped; |
| |
| /** The currently active branch of the union. -1 if no branch |
| * is selected. */ |
| int discriminant; |
| |
| /* The rest of the struct is taken up by the inline storage |
| * needed for the active branch. */ |
| } avro_resolved_wunion_value_t; |
| |
| /** Return a pointer to the active branch within a union struct. */ |
| #define avro_resolved_wunion_branch(_wunion) \ |
| (((char *) (_wunion)) + sizeof(avro_resolved_wunion_value_t)) |
| |
| |
| static void |
| avro_resolved_wunion_reader_calculate_size(avro_resolved_reader_t *iface) |
| { |
| avro_resolved_wunion_reader_t *uiface = |
| container_of(iface, avro_resolved_wunion_reader_t, parent); |
| |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for %s->%s", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| |
| size_t i; |
| size_t max_branch_size = 0; |
| for (i = 0; i < uiface->branch_count; i++) { |
| if (uiface->branch_resolvers[i] == NULL) { |
| DEBUG("No match for writer union branch %" PRIsz, i); |
| } else { |
| avro_resolved_reader_calculate_size |
| (uiface->branch_resolvers[i]); |
| size_t branch_size = |
| uiface->branch_resolvers[i]->instance_size; |
| DEBUG("Writer branch %" PRIsz " has size %" PRIsz, i, branch_size); |
| if (branch_size > max_branch_size) { |
| max_branch_size = branch_size; |
| } |
| } |
| } |
| |
| DEBUG("Maximum branch size is %" PRIsz, max_branch_size); |
| iface->instance_size = |
| sizeof(avro_resolved_wunion_value_t) + max_branch_size; |
| DEBUG("Total union size is %" PRIsz, iface->instance_size); |
| } |
| |
| |
| static void |
| avro_resolved_wunion_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| avro_resolved_wunion_reader_t *uiface = |
| container_of(iface, avro_resolved_wunion_reader_t, parent); |
| |
| if (uiface->branch_resolvers != NULL) { |
| size_t i; |
| for (i = 0; i < uiface->branch_count; i++) { |
| if (uiface->branch_resolvers[i] != NULL) { |
| free_resolver(uiface->branch_resolvers[i], freeing); |
| } |
| } |
| avro_free(uiface->branch_resolvers, |
| uiface->branch_count * sizeof(avro_resolved_reader_t *)); |
| } |
| |
| avro_schema_decref(iface->wschema); |
| avro_schema_decref(iface->rschema); |
| avro_freet(avro_resolved_wunion_reader_t, iface); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_init(const avro_resolved_reader_t *iface, void *vself) |
| { |
| AVRO_UNUSED(iface); |
| avro_resolved_wunion_value_t *self = (avro_resolved_wunion_value_t *) vself; |
| self->discriminant = -1; |
| return 0; |
| } |
| |
| static void |
| avro_resolved_wunion_reader_done(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_wunion_reader_t *uiface = |
| container_of(iface, avro_resolved_wunion_reader_t, parent); |
| avro_resolved_wunion_value_t *self = (avro_resolved_wunion_value_t *) vself; |
| if (self->discriminant >= 0) { |
| avro_resolved_reader_done |
| (uiface->branch_resolvers[self->discriminant], |
| avro_resolved_wunion_branch(self)); |
| self->discriminant = -1; |
| } |
| } |
| |
| static int |
| avro_resolved_wunion_reader_reset(const avro_resolved_reader_t *iface, void *vself) |
| { |
| const avro_resolved_wunion_reader_t *uiface = |
| container_of(iface, avro_resolved_wunion_reader_t, parent); |
| avro_resolved_wunion_value_t *self = (avro_resolved_wunion_value_t *) vself; |
| |
| /* Keep the same branch selected, for the common case that we're |
| * about to reuse it. */ |
| if (self->discriminant >= 0) { |
| return avro_resolved_reader_reset_wrappers |
| (uiface->branch_resolvers[self->discriminant], |
| avro_resolved_wunion_branch(self)); |
| } |
| |
| return 0; |
| } |
| |
| static int |
| avro_resolved_wunion_get_real_src(const avro_value_iface_t *viface, |
| const void *vself, avro_value_t *real_src) |
| { |
| int rval; |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_wunion_reader_t *uiface = |
| container_of(iface, avro_resolved_wunion_reader_t, parent); |
| avro_resolved_wunion_value_t *self = (avro_resolved_wunion_value_t *) vself; |
| int writer_disc; |
| check(rval, avro_value_get_discriminant(&self->wrapped, &writer_disc)); |
| DEBUG("Writer is branch %d", writer_disc); |
| |
| if (uiface->branch_resolvers[writer_disc] == NULL) { |
| avro_set_error("Reader isn't compatible with writer branch %d", |
| writer_disc); |
| return EINVAL; |
| } |
| |
| if (self->discriminant == writer_disc) { |
| DEBUG("Writer branch %d already selected", writer_disc); |
| } else { |
| if (self->discriminant >= 0) { |
| DEBUG("Finalizing old writer branch %d", self->discriminant); |
| avro_resolved_reader_done |
| (uiface->branch_resolvers[self->discriminant], |
| avro_resolved_wunion_branch(self)); |
| } |
| DEBUG("Initializing writer branch %d", writer_disc); |
| check(rval, avro_resolved_reader_init |
| (uiface->branch_resolvers[writer_disc], |
| avro_resolved_wunion_branch(self))); |
| self->discriminant = writer_disc; |
| } |
| |
| real_src->iface = &uiface->branch_resolvers[writer_disc]->parent; |
| real_src->self = avro_resolved_wunion_branch(self); |
| return avro_value_get_current_branch(&self->wrapped, (avro_value_t *) real_src->self); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_boolean(const avro_value_iface_t *viface, |
| const void *vself, int *out) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_boolean(&src, out); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_bytes(const avro_value_iface_t *viface, |
| const void *vself, const void **buf, size_t *size) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_bytes(&src, buf, size); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_grab_bytes(const avro_value_iface_t *viface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_grab_bytes(&src, dest); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_double(const avro_value_iface_t *viface, |
| const void *vself, double *out) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_double(&src, out); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_float(const avro_value_iface_t *viface, |
| const void *vself, float *out) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_float(&src, out); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_int(const avro_value_iface_t *viface, |
| const void *vself, int32_t *out) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_int(&src, out); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_long(const avro_value_iface_t *viface, |
| const void *vself, int64_t *out) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_long(&src, out); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_null(const avro_value_iface_t *viface, |
| const void *vself) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_null(&src); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_string(const avro_value_iface_t *viface, |
| const void *vself, const char **str, size_t *size) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_string(&src, str, size); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_grab_string(const avro_value_iface_t *viface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_grab_string(&src, dest); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_enum(const avro_value_iface_t *viface, |
| const void *vself, int *out) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_enum(&src, out); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_fixed(const avro_value_iface_t *viface, |
| const void *vself, const void **buf, size_t *size) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_fixed(&src, buf, size); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_grab_fixed(const avro_value_iface_t *viface, |
| const void *vself, avro_wrapped_buffer_t *dest) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_grab_fixed(&src, dest); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_boolean(const avro_value_iface_t *viface, |
| void *vself, int val) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_boolean(&src, val); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_bytes(const avro_value_iface_t *viface, |
| void *vself, void *buf, size_t size) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_bytes(&src, buf, size); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_give_bytes(const avro_value_iface_t *viface, |
| void *vself, avro_wrapped_buffer_t *buf) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_give_bytes(&src, buf); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_double(const avro_value_iface_t *viface, |
| void *vself, double val) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_double(&src, val); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_float(const avro_value_iface_t *viface, |
| void *vself, float val) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_float(&src, val); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_int(const avro_value_iface_t *viface, |
| void *vself, int32_t val) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_int(&src, val); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_long(const avro_value_iface_t *viface, |
| void *vself, int64_t val) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_long(&src, val); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_null(const avro_value_iface_t *viface, |
| void *vself) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_null(&src); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_string(const avro_value_iface_t *viface, |
| void *vself, const char *str) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_string(&src, str); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_string_len(const avro_value_iface_t *viface, |
| void *vself, const char *str, size_t size) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_string_len(&src, str, size); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_give_string_len(const avro_value_iface_t *viface, |
| void *vself, avro_wrapped_buffer_t *buf) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_give_string_len(&src, buf); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_enum(const avro_value_iface_t *viface, |
| void *vself, int val) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_enum(&src, val); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_fixed(const avro_value_iface_t *viface, |
| void *vself, void *buf, size_t size) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_fixed(&src, buf, size); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_give_fixed(const avro_value_iface_t *viface, |
| void *vself, avro_wrapped_buffer_t *dest) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_give_fixed(&src, dest); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_size(const avro_value_iface_t *viface, |
| const void *vself, size_t *size) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_size(&src, size); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_by_index(const avro_value_iface_t *viface, |
| const void *vself, size_t index, |
| avro_value_t *child, const char **name) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_by_index(&src, index, child, name); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_by_name(const avro_value_iface_t *viface, |
| const void *vself, const char *name, |
| avro_value_t *child, size_t *index) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_by_name(&src, name, child, index); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_discriminant(const avro_value_iface_t *viface, |
| const void *vself, int *out) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_discriminant(&src, out); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_get_current_branch(const avro_value_iface_t *viface, |
| const void *vself, avro_value_t *branch) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_get_current_branch(&src, branch); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_append(const avro_value_iface_t *viface, |
| void *vself, avro_value_t *child_out, |
| size_t *new_index) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_append(&src, child_out, new_index); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_add(const avro_value_iface_t *viface, |
| void *vself, const char *key, |
| avro_value_t *child, size_t *index, int *is_new) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_add(&src, key, child, index, is_new); |
| } |
| |
| static int |
| avro_resolved_wunion_reader_set_branch(const avro_value_iface_t *viface, |
| void *vself, int discriminant, |
| avro_value_t *branch) |
| { |
| int rval; |
| avro_value_t src; |
| check(rval, avro_resolved_wunion_get_real_src(viface, vself, &src)); |
| return avro_value_set_branch(&src, discriminant, branch); |
| } |
| |
| static avro_resolved_wunion_reader_t * |
| avro_resolved_wunion_reader_create(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| avro_resolved_reader_t *self = (avro_resolved_reader_t *) avro_new(avro_resolved_wunion_reader_t); |
| memset(self, 0, sizeof(avro_resolved_wunion_reader_t)); |
| |
| self->parent.incref_iface = avro_resolved_reader_incref_iface; |
| self->parent.decref_iface = avro_resolved_reader_decref_iface; |
| self->parent.incref = avro_resolved_reader_incref; |
| self->parent.decref = avro_resolved_reader_decref; |
| self->parent.reset = avro_resolved_reader_reset; |
| self->parent.get_type = avro_resolved_reader_get_type; |
| self->parent.get_schema = avro_resolved_reader_get_schema; |
| |
| self->parent.get_boolean = avro_resolved_wunion_reader_get_boolean; |
| self->parent.grab_bytes = avro_resolved_wunion_reader_grab_bytes; |
| self->parent.get_bytes = avro_resolved_wunion_reader_get_bytes; |
| self->parent.get_double = avro_resolved_wunion_reader_get_double; |
| self->parent.get_float = avro_resolved_wunion_reader_get_float; |
| self->parent.get_int = avro_resolved_wunion_reader_get_int; |
| self->parent.get_long = avro_resolved_wunion_reader_get_long; |
| self->parent.get_null = avro_resolved_wunion_reader_get_null; |
| self->parent.get_string = avro_resolved_wunion_reader_get_string; |
| self->parent.grab_string = avro_resolved_wunion_reader_grab_string; |
| self->parent.get_enum = avro_resolved_wunion_reader_get_enum; |
| self->parent.get_fixed = avro_resolved_wunion_reader_get_fixed; |
| self->parent.grab_fixed = avro_resolved_wunion_reader_grab_fixed; |
| |
| self->parent.set_boolean = avro_resolved_wunion_reader_set_boolean; |
| self->parent.set_bytes = avro_resolved_wunion_reader_set_bytes; |
| self->parent.give_bytes = avro_resolved_wunion_reader_give_bytes; |
| self->parent.set_double = avro_resolved_wunion_reader_set_double; |
| self->parent.set_float = avro_resolved_wunion_reader_set_float; |
| self->parent.set_int = avro_resolved_wunion_reader_set_int; |
| self->parent.set_long = avro_resolved_wunion_reader_set_long; |
| self->parent.set_null = avro_resolved_wunion_reader_set_null; |
| self->parent.set_string = avro_resolved_wunion_reader_set_string; |
| self->parent.set_string_len = avro_resolved_wunion_reader_set_string_len; |
| self->parent.give_string_len = avro_resolved_wunion_reader_give_string_len; |
| self->parent.set_enum = avro_resolved_wunion_reader_set_enum; |
| self->parent.set_fixed = avro_resolved_wunion_reader_set_fixed; |
| self->parent.give_fixed = avro_resolved_wunion_reader_give_fixed; |
| |
| self->parent.get_size = avro_resolved_wunion_reader_get_size; |
| self->parent.get_by_index = avro_resolved_wunion_reader_get_by_index; |
| self->parent.get_by_name = avro_resolved_wunion_reader_get_by_name; |
| self->parent.get_discriminant = avro_resolved_wunion_reader_get_discriminant; |
| self->parent.get_current_branch = avro_resolved_wunion_reader_get_current_branch; |
| |
| self->parent.append = avro_resolved_wunion_reader_append; |
| self->parent.add = avro_resolved_wunion_reader_add; |
| self->parent.set_branch = avro_resolved_wunion_reader_set_branch; |
| |
| self->refcount = 1; |
| self->wschema = avro_schema_incref(wschema); |
| self->rschema = avro_schema_incref(rschema); |
| self->calculate_size = avro_resolved_wunion_reader_calculate_size; |
| self->free_iface = avro_resolved_wunion_reader_free_iface; |
| self->init = avro_resolved_wunion_reader_init; |
| self->done = avro_resolved_wunion_reader_done; |
| self->reset_wrappers = avro_resolved_wunion_reader_reset; |
| return container_of(self, avro_resolved_wunion_reader_t, parent); |
| } |
| |
| static avro_resolved_reader_t * |
| try_writer_union(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * For a writer union, we check each branch of the union in turn |
| * against the reader schema. For each one that is compatible, |
| * we save the child resolver that can be used to process a |
| * writer value of that branch. |
| */ |
| |
| size_t branch_count = avro_schema_union_size(wschema); |
| DEBUG("Checking %" PRIsz "-branch writer union schema", branch_count); |
| |
| avro_resolved_wunion_reader_t *uself = |
| avro_resolved_wunion_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, uself); |
| |
| avro_resolved_reader_t **branch_resolvers = |
| (avro_resolved_reader_t **) avro_calloc(branch_count, sizeof(avro_resolved_reader_t *)); |
| int some_branch_compatible = 0; |
| |
| size_t i; |
| for (i = 0; i < branch_count; i++) { |
| avro_schema_t branch_schema = |
| avro_schema_union_branch(wschema, i); |
| |
| DEBUG("Resolving writer union branch %" PRIsz " (%s)", i, |
| avro_schema_type_name(branch_schema)); |
| |
| /* |
| * Try to recursively resolve this branch of the writer |
| * union against the reader schema. Don't raise |
| * an error if this fails — we just need one of |
| * the writer branches to be compatible. |
| */ |
| |
| branch_resolvers[i] = |
| avro_resolved_reader_new_memoized(state, branch_schema, rschema); |
| if (branch_resolvers[i] == NULL) { |
| DEBUG("No match for writer union branch %" PRIsz, i); |
| } else { |
| DEBUG("Found match for writer union branch %" PRIsz, i); |
| some_branch_compatible = 1; |
| } |
| } |
| |
| /* |
| * If we didn't find a match, that's an error. |
| */ |
| |
| if (!some_branch_compatible) { |
| DEBUG("No writer union branches match"); |
| avro_set_error("No branches in the writer are compatible " |
| "with reader schema %s", |
| avro_schema_type_name(rschema)); |
| goto error; |
| } |
| |
| uself->branch_count = branch_count; |
| uself->branch_resolvers = branch_resolvers; |
| return &uself->parent; |
| |
| error: |
| /* |
| * Clean up any resolver we might have already created. |
| */ |
| |
| avro_memoize_delete(&state->mem, wschema, rschema); |
| avro_value_iface_decref(&uself->parent.parent); |
| |
| { |
| unsigned int i; |
| for (i = 0; i < branch_count; i++) { |
| if (branch_resolvers[i]) { |
| avro_value_iface_decref(&branch_resolvers[i]->parent); |
| } |
| } |
| } |
| |
| avro_free(branch_resolvers, branch_count * sizeof(avro_resolved_reader_t *)); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * reader union |
| */ |
| |
| /* |
| * For reader unions, we only resolve them against writers which aren't |
| * unions. (We'll have already broken any writer union apart into its |
| * separate branches.) We just have to record which branch of the |
| * reader union the writer schema is compatible with. |
| */ |
| |
| typedef struct avro_resolved_runion_reader { |
| avro_resolved_reader_t parent; |
| |
| /* The reader union branch that's compatible with the writer |
| * schema. */ |
| size_t active_branch; |
| |
| /* A child resolver for the reader branch. */ |
| avro_resolved_reader_t *branch_resolver; |
| } avro_resolved_runion_reader_t; |
| |
| |
| static void |
| avro_resolved_runion_reader_calculate_size(avro_resolved_reader_t *iface) |
| { |
| avro_resolved_runion_reader_t *uiface = |
| container_of(iface, avro_resolved_runion_reader_t, parent); |
| |
| /* Only calculate the size for any resolver once */ |
| iface->calculate_size = NULL; |
| |
| DEBUG("Calculating size for %s->%s", |
| avro_schema_type_name((iface)->wschema), |
| avro_schema_type_name((iface)->rschema)); |
| |
| avro_resolved_reader_calculate_size(uiface->branch_resolver); |
| iface->instance_size = uiface->branch_resolver->instance_size; |
| } |
| |
| |
| static void |
| avro_resolved_runion_reader_free_iface(avro_resolved_reader_t *iface, st_table *freeing) |
| { |
| avro_resolved_runion_reader_t *uiface = |
| container_of(iface, avro_resolved_runion_reader_t, parent); |
| |
| if (uiface->branch_resolver != NULL) { |
| free_resolver(uiface->branch_resolver, freeing); |
| } |
| |
| avro_schema_decref(iface->wschema); |
| avro_schema_decref(iface->rschema); |
| avro_freet(avro_resolved_runion_reader_t, iface); |
| } |
| |
| static int |
| avro_resolved_runion_reader_init(const avro_resolved_reader_t *iface, void *vself) |
| { |
| avro_resolved_runion_reader_t *uiface = |
| container_of(iface, avro_resolved_runion_reader_t, parent); |
| return avro_resolved_reader_init(uiface->branch_resolver, vself); |
| } |
| |
| static void |
| avro_resolved_runion_reader_done(const avro_resolved_reader_t *iface, void *vself) |
| { |
| avro_resolved_runion_reader_t *uiface = |
| container_of(iface, avro_resolved_runion_reader_t, parent); |
| avro_resolved_reader_done(uiface->branch_resolver, vself); |
| } |
| |
| static int |
| avro_resolved_runion_reader_reset(const avro_resolved_reader_t *iface, void *vself) |
| { |
| avro_resolved_runion_reader_t *uiface = |
| container_of(iface, avro_resolved_runion_reader_t, parent); |
| return avro_resolved_reader_reset_wrappers(uiface->branch_resolver, vself); |
| } |
| |
| static int |
| avro_resolved_runion_reader_get_discriminant(const avro_value_iface_t *viface, |
| const void *vself, int *out) |
| { |
| AVRO_UNUSED(vself); |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_runion_reader_t *uiface = |
| container_of(iface, avro_resolved_runion_reader_t, parent); |
| DEBUG("Reader union is branch %" PRIsz, uiface->active_branch); |
| *out = uiface->active_branch; |
| return 0; |
| } |
| |
| static int |
| avro_resolved_runion_reader_get_current_branch(const avro_value_iface_t *viface, |
| const void *vself, avro_value_t *branch) |
| { |
| const avro_resolved_reader_t *iface = |
| container_of(viface, avro_resolved_reader_t, parent); |
| const avro_resolved_runion_reader_t *uiface = |
| container_of(iface, avro_resolved_runion_reader_t, parent); |
| DEBUG("Getting reader branch %" PRIsz " for union %p", uiface->active_branch, vself); |
| branch->iface = &uiface->branch_resolver->parent; |
| branch->self = (void *) vself; |
| return 0; |
| } |
| |
| static avro_resolved_runion_reader_t * |
| avro_resolved_runion_reader_create(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| avro_resolved_reader_t *self = (avro_resolved_reader_t *) avro_new(avro_resolved_runion_reader_t); |
| memset(self, 0, sizeof(avro_resolved_runion_reader_t)); |
| |
| self->parent.incref_iface = avro_resolved_reader_incref_iface; |
| self->parent.decref_iface = avro_resolved_reader_decref_iface; |
| self->parent.incref = avro_resolved_reader_incref; |
| self->parent.decref = avro_resolved_reader_decref; |
| self->parent.reset = avro_resolved_reader_reset; |
| self->parent.get_type = avro_resolved_reader_get_type; |
| self->parent.get_schema = avro_resolved_reader_get_schema; |
| self->parent.get_discriminant = avro_resolved_runion_reader_get_discriminant; |
| self->parent.get_current_branch = avro_resolved_runion_reader_get_current_branch; |
| |
| self->refcount = 1; |
| self->wschema = avro_schema_incref(wschema); |
| self->rschema = avro_schema_incref(rschema); |
| self->calculate_size = avro_resolved_runion_reader_calculate_size; |
| self->free_iface = avro_resolved_runion_reader_free_iface; |
| self->init = avro_resolved_runion_reader_init; |
| self->done = avro_resolved_runion_reader_done; |
| self->reset_wrappers = avro_resolved_runion_reader_reset; |
| return container_of(self, avro_resolved_runion_reader_t, parent); |
| } |
| |
| static avro_resolved_reader_t * |
| try_reader_union(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * For a reader union, we have to identify which branch |
| * corresponds to the writer schema. (The writer won't be a |
| * union, since we'll have already broken it into its branches.) |
| */ |
| |
| size_t branch_count = avro_schema_union_size(rschema); |
| DEBUG("Checking %" PRIsz "-branch reader union schema", branch_count); |
| |
| avro_resolved_runion_reader_t *uself = |
| avro_resolved_runion_reader_create(wschema, rschema); |
| avro_memoize_set(&state->mem, wschema, rschema, uself); |
| |
| size_t i; |
| for (i = 0; i < branch_count; i++) { |
| avro_schema_t branch_schema = |
| avro_schema_union_branch(rschema, i); |
| |
| DEBUG("Resolving reader union branch %" PRIsz " (%s)", i, |
| avro_schema_type_name(branch_schema)); |
| |
| /* |
| * Try to recursively resolve this branch of the reader |
| * union against the writer schema. Don't raise |
| * an error if this fails — we just need one of |
| * the reader branches to be compatible. |
| */ |
| |
| uself->branch_resolver = |
| avro_resolved_reader_new_memoized(state, wschema, branch_schema); |
| if (uself->branch_resolver == NULL) { |
| DEBUG("No match for reader union branch %" PRIsz, i); |
| } else { |
| DEBUG("Found match for reader union branch %" PRIsz, i); |
| uself->active_branch = i; |
| return &uself->parent; |
| } |
| } |
| |
| /* |
| * If we didn't find a match, that's an error. |
| */ |
| |
| DEBUG("No reader union branches match"); |
| avro_set_error("No branches in the reader are compatible " |
| "with writer schema %s", |
| avro_schema_type_name(wschema)); |
| goto error; |
| |
| error: |
| /* |
| * Clean up any resolver we might have already created. |
| */ |
| |
| avro_memoize_delete(&state->mem, wschema, rschema); |
| avro_value_iface_decref(&uself->parent.parent); |
| return NULL; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * Schema type dispatcher |
| */ |
| |
| static avro_resolved_reader_t * |
| avro_resolved_reader_new_memoized(memoize_state_t *state, |
| avro_schema_t wschema, avro_schema_t rschema) |
| { |
| check_param(NULL, is_avro_schema(wschema), "writer schema"); |
| check_param(NULL, is_avro_schema(rschema), "reader schema"); |
| |
| /* |
| * First see if we've already matched these two schemas. If so, |
| * just return that resolver. |
| */ |
| |
| avro_resolved_reader_t *saved = NULL; |
| if (avro_memoize_get(&state->mem, wschema, rschema, (void **) &saved)) { |
| DEBUG("Already resolved %s%s%s->%s%s%s", |
| is_avro_link(wschema)? "[": "", |
| avro_schema_type_name(wschema), |
| is_avro_link(wschema)? "]": "", |
| is_avro_link(rschema)? "[": "", |
| avro_schema_type_name(rschema), |
| is_avro_link(rschema)? "]": ""); |
| return saved; |
| } else { |
| DEBUG("Resolving %s%s%s->%s%s%s", |
| is_avro_link(wschema)? "[": "", |
| avro_schema_type_name(wschema), |
| is_avro_link(wschema)? "]": "", |
| is_avro_link(rschema)? "[": "", |
| avro_schema_type_name(rschema), |
| is_avro_link(rschema)? "]": ""); |
| } |
| |
| /* |
| * Otherwise we have some work to do. First check if the writer |
| * schema is a union. If so, break it apart. |
| */ |
| |
| if (is_avro_union(wschema)) { |
| return try_writer_union(state, wschema, rschema); |
| } |
| |
| else if (is_avro_link(wschema)) { |
| return try_wlink(state, wschema, rschema); |
| } |
| |
| /* |
| * If the writer isn't a union, than choose a resolver based on |
| * the reader schema. |
| */ |
| |
| switch (avro_typeof(rschema)) |
| { |
| case AVRO_BOOLEAN: |
| return try_boolean(state, wschema, rschema); |
| |
| case AVRO_BYTES: |
| return try_bytes(state, wschema, rschema); |
| |
| case AVRO_DOUBLE: |
| return try_double(state, wschema, rschema); |
| |
| case AVRO_FLOAT: |
| return try_float(state, wschema, rschema); |
| |
| case AVRO_INT32: |
| return try_int(state, wschema, rschema); |
| |
| case AVRO_INT64: |
| return try_long(state, wschema, rschema); |
| |
| case AVRO_NULL: |
| return try_null(state, wschema, rschema); |
| |
| case AVRO_STRING: |
| return try_string(state, wschema, rschema); |
| |
| case AVRO_ARRAY: |
| return try_array(state, wschema, rschema); |
| |
| case AVRO_ENUM: |
| return try_enum(state, wschema, rschema); |
| |
| case AVRO_FIXED: |
| return try_fixed(state, wschema, rschema); |
| |
| case AVRO_MAP: |
| return try_map(state, wschema, rschema); |
| |
| case AVRO_RECORD: |
| return try_record(state, wschema, rschema); |
| |
| case AVRO_UNION: |
| return try_reader_union(state, wschema, rschema); |
| |
| case AVRO_LINK: |
| return try_rlink(state, wschema, rschema); |
| |
| default: |
| avro_set_error("Unknown reader schema type"); |
| return NULL; |
| } |
| |
| return NULL; |
| } |
| |
| |
| avro_value_iface_t * |
| avro_resolved_reader_new(avro_schema_t wschema, avro_schema_t rschema) |
| { |
| /* |
| * Create a state to keep track of the value implementations |
| * that we create for each subschema. |
| */ |
| |
| memoize_state_t state; |
| avro_memoize_init(&state.mem); |
| state.links = NULL; |
| |
| /* |
| * Create the value implementations. |
| */ |
| |
| avro_resolved_reader_t *result = |
| avro_resolved_reader_new_memoized(&state, wschema, rschema); |
| if (result == NULL) { |
| avro_memoize_done(&state.mem); |
| return NULL; |
| } |
| |
| /* |
| * Fix up any link schemas so that their value implementations |
| * point to their target schemas' implementations. |
| */ |
| |
| avro_resolved_reader_calculate_size(result); |
| while (state.links != NULL) { |
| avro_resolved_link_reader_t *liface = state.links; |
| avro_resolved_reader_calculate_size(liface->target_resolver); |
| state.links = liface->next; |
| liface->next = NULL; |
| } |
| |
| /* |
| * And now we can return. |
| */ |
| |
| avro_memoize_done(&state.mem); |
| return &result->parent; |
| } |