/* $Id$ * * 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 * * http://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. */ /* * etch_binary_tdi.c -- binary tagged data input implementation. */ #include "etch_binary_tdi.h" #include "etch_cache.h" #include "etch_structval.h" #include "etch_arrayval.h" #include "etch_tagged_data.h" #include "etch_default_value_factory.h" #include "etch_encoding.h" #include "etch_exception.h" #include "etch_nativearray.h" #include "etch_log.h" #include "etch_objecttypes.h" #include "etch_mem.h" static const char* LOG_CATEGORY = "etch_binary_tdi"; /* - - - - - - - - - - - - - - - - - - - - * private method signatures * - - - - - - - - - - - - - - - - - - - - */ i_binary_tdi* new_binarytdi_vtable(); etch_message* bintdi_start_message (tagged_data_input*); int bintdi_end_message (tagged_data_input*, etch_message*); etch_message* bintdi_read_message(tagged_data_input*, etch_flexbuffer*); etch_structvalue* bintdi_start_struct(tagged_data_input*); etch_structvalue* bintdi_read_struct (tagged_data_input*); int bintdi_end_struct (tagged_data_input*, etch_structvalue*); etch_arrayvalue* bintdi_start_array(tagged_data_input*); etch_arrayvalue* bintdi_read_array (tagged_data_input*, etch_validator*); int bintdi_end_array(tagged_data_input*, etch_arrayvalue*); etch_arrayvalue* bintdi_alloc_array(tagged_data_input*, const byte array_content_type, etch_type* custom_type, const int ndims, const int nelements); int bintdi_read_keys_values(binary_tagged_data_input*, etch_structvalue*); int bintdi_read_values(binary_tagged_data_input*, etch_arrayvalue*, etch_validator*); etch_object* bintdi_read_value (binary_tagged_data_input*, etch_validator*); etch_object* bintdi_read_valuex(binary_tagged_data_input*, etch_validator*, boolean); etch_type* bintdi_get_custom_structtype(etch_object*, const unsigned short, const unsigned short); etch_type* bintdi_read_type(binary_tagged_data_input*); etch_int32* bintdi_read_intvalue(binary_tagged_data_input*); int bintdi_read_value_rawint(binary_tagged_data_input* tdi, int* out); etch_validator* bintdi_get_validator_for(binary_tagged_data_input* tdi, etch_field* field); etch_object* bintdi_validate_value(binary_tagged_data_input*, etch_validator*, boolean is_none_ok, etch_object*); etch_object* bintdi_validate_valuex(binary_tagged_data_input*, etch_validator*, boolean is_none_ok, etch_object*); int bintdi_get_native_type(const signed char external_typecode, etch_array_id_params* out); int bintdi_get_component_type(tagged_data_input*, const byte array_content_type, etch_type* custom_type, const int dims, etch_array_id_params* out); signed char bintagdata_get_native_typecode(const unsigned short, const unsigned short); /* - - - - - - - - - - - - - - - - - - - - * constructors/destructors * - - - - - - - - - - - - - - - - - - - - */ /** * destroy_binary_tagged_data_input() */ int destroy_binary_tagged_data_input(void* data) { binary_tagged_data_input* tdi = (binary_tagged_data_input*)data; if (!is_etchobj_static_content(tdi)) etch_object_destroy(tdi->impl); /* destroy private instance data */ etch_free(tdi->static_nullobj); etch_free(tdi->static_eodmarker); clear_etchobj_static_all(tdi->static_emptystring); etch_object_destroy(tdi->static_emptystring); return destroy_objectex((etch_object*)tdi); } /** * clone_tagged_data_input() * tdi copy constructor. if the tdi object implements a separate instance data * object, that object is cloned as well. */ void* clone_binary_tagged_data_input(void* data) { binary_tagged_data_input* tdi = (binary_tagged_data_input*)data; binary_tagged_data_input* newtdi = (binary_tagged_data_input*) clone_object((etch_object*) tdi); newtdi->impl = tdi->impl? tdi->impl->clone(tdi->impl): NULL; return newtdi; } /** * new_binary_tagdata_input() * binary_tagged_data_input constructor */ binary_tagged_data_input* new_binary_tagdata_input(etch_value_factory* vf) { i_binary_tdi* vtab = NULL; binary_tagged_data_input* tdi = (binary_tagged_data_input*) new_object (sizeof(binary_tagged_data_input), ETCHTYPEB_BINARYTDI, CLASSID_BINARYTDI); ((etch_object*)tdi)->destroy = destroy_binary_tagged_data_input; ((etch_object*)tdi)->clone = clone_binary_tagged_data_input; tdi->vf = vf; vtab = etch_cache_find(get_vtable_cachehkey(CLASSID_BINARYTDI_VTAB), 0); if(!vtab) { vtab = new_binarytdi_vtable(); etch_cache_insert(((etch_object*)vtab)->get_hashkey(vtab), vtab, FALSE); } ((etch_object*)tdi)->vtab = (vtabmask*)vtab; tdi->vtor_int = etchvtor_int32_get(0); tdi->static_nullobj = etchtagdata_new_nullobj(TRUE); tdi->static_eodmarker = etchtagdata_new_eodmarker(TRUE); tdi->static_emptystring = etchtagdata_new_emptystring(TRUE); return tdi; } /** * new_binary_tdi() * casts result to generic tdi for use by interfaces */ tagged_data_input* new_binary_tdi(etch_value_factory* vf) { return (tagged_data_input*) new_binary_tagdata_input(vf); } /** * new_new_binarytdi_vtable() * constructor for binary tdi virtual function table */ i_binary_tdi* new_binarytdi_vtable() { etchparentinfo* inheritlist = new_etch_inheritance_list(3, 2, NULL); i_binary_tdi* vtab = new_vtable(NULL, sizeof(i_binary_tdi), CLASSID_BINARYTDI_VTAB); /* i_tagged_data_input */ vtab->start_message = bintdi_start_message; vtab->read_message = bintdi_read_message; vtab->end_message = bintdi_end_message; vtab->start_struct = bintdi_start_struct; vtab->read_struct = bintdi_read_struct; vtab->end_struct = bintdi_end_struct; vtab->start_array = bintdi_start_array; vtab->read_array = bintdi_read_array; vtab->end_array = bintdi_end_array; /* i_tagdata */ vtab->check_value = etchtagdata_check_value; vtab->get_native_type = bintdi_get_native_type; vtab->get_native_type_code = bintagdata_get_native_typecode; vtab->get_custom_structtype = bintdi_get_custom_structtype; /* inheritance */ inheritlist[1].o.obj_type = ETCHTYPEB_TAGDATAINP; inheritlist[1].c.class_id = CLASSID_TAGDATAINP; inheritlist[2].o.obj_type = ETCHTYPEB_TAGDATA; inheritlist[2].c.class_id = CLASSID_TAGDATA; vtab->inherits_from = inheritlist; return vtab; } /* - - - - - - - - - - - - - - - - - - - - * read message * - - - - - - - - - - - - - - - - - - - - */ /** * bintdi_start_message() * starts reading a message from the stream. * returns NULL if the wire data was insufficient to construct a * message object, otherwise returns the new message object, * of the type read off the wire herein. */ etch_message* bintdi_start_message(tagged_data_input* tdix) { binary_tagged_data_input* tdi = (binary_tagged_data_input*) tdix; etch_type* typeobj = NULL; /* not owned here */ etch_message* newmsg = NULL; /* disposable, returned */ int message_itemcount = 0, result = 0; byte wire_version = 0; do { result = etch_flexbuf_get_byte (tdi->flexbuf, &wire_version); if (wire_version != ETCH_BINTAGDATA_CURRENT_VERSION) { ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR,"message version expected %d found %d", ETCH_BINTAGDATA_CURRENT_VERSION, wire_version); break; } /* bintdi_read_type returns us a non-disposable reference to a global type, * which we then give to the new message, which does not own its type. */ if (NULL == (typeobj = bintdi_read_type (tdi))) break; if (-1 != bintdi_read_value_rawint (tdi, &message_itemcount)) newmsg = new_message(typeobj, message_itemcount, tdi->vf); } while(0); if(newmsg) { ETCH_LOG(LOG_CATEGORY, ETCH_LOG_DEBUG, "message receive starts\n"); } else { ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR, "error starting message receive\n"); } return newmsg; } /** * bintdi_end_message() * end message deserialization */ int bintdi_end_message(tagged_data_input* tdi, etch_message* msg) { int result = 0; /* if the newly-deserialized message is not a reply message, * there is nothing to do here, since bintdi_read_keys_values() * already read the eod marker. if it is a reply message, and * if the message contains an exception, we will ensure that the * message result object both exists and reflects that exception. */ if (etch_message_get_in_reply_to (msg)) { etch_field* xkey = builtins._mf_msg; /* look for an exception in the newly-deserialized message */ etch_exception* excpobj = (etch_exception*) etch_message_get (msg, xkey); if (is_etch_exception(excpobj)) { /* look for a result object in the message */ etch_field* resobj_key = builtins._mf_result; etch_object* resobj = etch_message_get (msg, resobj_key); ETCH_LOG(LOG_CATEGORY, ETCH_LOG_DEBUG, "exception found in message\n"); //replace result with exception object //TODO memory leak here? (resobj not destroyed, should we?) resobj = ((etch_object*)excpobj)->clone(excpobj); result = etch_message_put (msg, resobj_key, resobj); } } return result; } /** * bintdi_read_message() * "non-static" read message version, accepts a tdi */ etch_message* bintdi_read_message (tagged_data_input* tdix, etch_flexbuffer* fbuf) { etch_message* newmsg = NULL; binary_tagged_data_input* tdi = (binary_tagged_data_input*) tdix; tdi->flexbuf = fbuf; if (NULL == (newmsg = bintdi_start_message(tdix))) return NULL; /* todo verify that this deserialization failure is eventually session_notify'ed */ if (-1 == bintdi_read_keys_values (tdi, newmsg->sv)) { etch_object_destroy(newmsg); return NULL; } bintdi_end_message(tdix, newmsg); return newmsg; } /** * bintdi_read_message_fromf() * reads a message from the supplied flex buffer */ etch_message* bintdi_read_message_fromf (etch_value_factory* vf, etch_flexbuffer* fbuf) { binary_tagged_data_input* tdi = new_binary_tagdata_input(vf); return bintdi_read_message((tagged_data_input*) tdi, fbuf); } /** * bintdi_read_message_from() * reads a message from the supplied data buffer */ etch_message* bintdi_read_message_from (etch_value_factory* vf, byte* buf, const int bufsize) { etch_flexbuffer* fbuf = new_flexbuffer_from(buf, bufsize, bufsize, 0); return bintdi_read_message_fromf(vf, fbuf); } /** * bintdi_read_message_fromo() * reads a message from the supplied data buffer, at the specified offset */ etch_message* bintdi_read_message_fromo (etch_value_factory* vf, byte* buf, const int bufsize, const int msglen, const int offset) { etch_flexbuffer* fbuf = new_flexbuffer_from(buf, bufsize, msglen, offset); return bintdi_read_message_fromf(vf, fbuf); } /* - - - - - - - - - - - - - - - - - - - - * read struct * - - - - - - - - - - - - - - - - - - - - */ /** * bintdi_start_struct() * starts reading a struct from the stream. */ etch_structvalue* bintdi_start_struct(tagged_data_input* tdix) { binary_tagged_data_input* tdi = (binary_tagged_data_input*) tdix; etch_structvalue* newsv = NULL; etch_type* thistype = NULL; int struct_itemcount = 0; /* bintdi_read_type returns us a non-disposable reference to a global type, * which we then give to the new structvalue, which does not own its type. */ if (NULL == (thistype = bintdi_read_type(tdi))) { return NULL; } if (-1 != bintdi_read_value_rawint(tdi, &struct_itemcount)) newsv = new_structvalue(thistype, struct_itemcount); return newsv; } /** * bintdi_end_struct() * does nothing since read_keys_values read to end of stream */ int bintdi_end_struct(tagged_data_input* tdi, etch_structvalue* sv) { return 0; } /** * bintdi_read_struct() * read a struct out of the buffer, create and return a new struct value */ etch_structvalue* bintdi_read_struct(tagged_data_input* tdix) { binary_tagged_data_input* tdi = (binary_tagged_data_input*) tdix; etch_structvalue* newsv = NULL; newsv = ((struct i_binary_tdi*)((etch_object*)tdi)->vtab)->start_struct((tagged_data_input*) tdi); if(newsv){ if (-1 == bintdi_read_keys_values(tdi, newsv)) { etch_object_destroy(newsv); newsv = NULL; }else { bintdi_end_struct(tdix, newsv); } } return newsv; } /* - - - - - - - - - - - - - - - - - - - - * read array * - - - - - - - - - - - - - - - - - - - - */ /** * bintdi_start_array() */ etch_arrayvalue* bintdi_start_array(tagged_data_input* tdix) { etch_type* custom_type = NULL; /* not owned here */ etch_arrayvalue* arrayval = NULL; /* owned by caller */ binary_tagged_data_input* tdi = (binary_tagged_data_input*) tdix; int numdimensions = 0, numelements = 0, result = 0; byte array_content_type = 0; result = etch_flexbuf_get_byte(tdi->flexbuf, &array_content_type); switch((signed char)array_content_type) { case ETCH_XTRNL_TYPECODE_CUSTOM: case ETCH_XTRNL_TYPECODE_STRUCT: /* bintdi_read_type returns a non-disposable type reference */ custom_type = bintdi_read_type(tdi); if (NULL == custom_type) return NULL; } bintdi_read_value_rawint(tdi, &numdimensions); bintdi_read_value_rawint(tdi, &numelements); if(numdimensions <= 0 || numelements < 0){ return NULL; } /* create the arrayvalue. we pass no memory ownership here */ arrayval = bintdi_alloc_array(tdix, array_content_type, custom_type, numdimensions, numelements); return arrayval; } /** * bintdi_end_array() * ends array in progress */ int bintdi_end_array(tagged_data_input* tdi, etch_arrayvalue* x) { return 0; } /** * bintdi_read_array() * read an array out of the buffer, create and return a new array object * * todo (eventually). arrays are not optimal. following the java binding model, * an array on the wire is read into an array_value. in c, this means an array * of objects, one object per array element. this can make for very large data * structures, 60 bytes of overhead per array element. we would like to instead * use the etch_nativearray format, where an array is a blob of bytes, with * attributes and methods describing how to index into the array. however * it was not known if doing so would paint the c binding into a corner at * some point, so for now, we create the arrayvalue just as the java binding, * and export that structure to an etch_nativearray when and if we need it. */ etch_arrayvalue* bintdi_read_array(tagged_data_input* tdix, etch_validator* vtor) { binary_tagged_data_input* tdi = (binary_tagged_data_input*) tdix; etch_arrayvalue* newarray = bintdi_start_array((tagged_data_input*) tdi); if (NULL == newarray) return NULL; if (-1 == bintdi_read_values(tdi, newarray, vtor)) { etch_object_destroy(newarray); return NULL; } bintdi_end_array((tagged_data_input*)tdi, newarray); return newarray; } /** * bintdi_alloc_array() * allocate an arrayvalue in which to read data for the pending array. * java binding allocates a native array here. we can't do that yet since we * don't have the attributes of each dimension until we get the entire array * out of the stream buffer, and we want to avoid lookahead if possible. * @return new array object, or NULL indicating exception condition */ etch_arrayvalue* bintdi_alloc_array(tagged_data_input* tdi, const byte array_content_type, etch_type* custom_type, const int ndims, const int nelements) { etch_array_id_params arraytype; etch_arrayvalue* arrayval = NULL; if (-1 == bintdi_get_component_type(tdi, array_content_type, custom_type, ndims, &arraytype)) return NULL; /* remarks regarding ownership of content for these arrayvalue objects. * first, recall that their content is etch objects wrapping data read from * the data buffer, and that the data so wrapped is owned by the wrapper. * ownership of memory for those base data objects is assigned up the line * until some object assumes responsibility. content for these arrayvalues * is either those wrapper objects, at dimension[0], or arrayvalue objects * at the higher dimensions. in all cases, the arryavalue owns its content, * and therefore its content will be destroyed with the arrayvalue. since * the destruction is recursive, destroying the top object destroys it all. */ arrayval = new_arrayvalue(array_content_type, custom_type, ndims, nelements, 0, FALSE, 0); if (NULL == arrayval) { return NULL; } /* validator will validate array based on this class */ ((etch_object*)arrayval)->class_id = arraytype.array_class_id; /* content type will be used later when we need to create a nativearray */ arrayval->content_obj_type = arraytype.content_obj_type; arrayval->content_class_id = arraytype.content_class_id; return arrayval; } /* - - - - - - - - - - - - - - - - - - - - - * read from stream and reconstruct objects * - - - - - - - - - - - - - - - - - - - - - */ /** * bintdi_read_intvalue() * convenience method used when an encoded integer is expected next in * the buffer, to read that value from the buffer and return it as an * etch_int32 object, ownership of which belongs to the caller. */ etch_int32* bintdi_read_intvalue(binary_tagged_data_input* tdi) { return (etch_int32*) bintdi_read_value(tdi, tdi->vtor_int); } /** * bintdi_read_bytes() * read all bytes from the buffer, returning those bytes * @param extra pad bytes e.g. when we are reading a string and need a null term */ byte* bintdi_read_bytes(binary_tagged_data_input* tdi, const int extra, int* psize) { byte* buf = NULL; int bytecount = 0, newbufsize = 0; if (-1 == bintdi_read_value_rawint(tdi, &bytecount)) return NULL; if(bytecount >= 0 && (size_t) bytecount <= etch_flexbuf_avail(tdi->flexbuf)) { newbufsize = bytecount + extra; buf = etch_malloc(newbufsize, ETCHTYPEB_BYTES); memset(buf, 0, newbufsize); etch_flexbuf_get_fully(tdi->flexbuf, buf, bytecount); if (psize) *psize = newbufsize; } return buf; } /** * bintdi_read_type() * read a type ID from the buffer, map to and return the associated static type */ etch_type* bintdi_read_type(binary_tagged_data_input* tdi) { etch_type* type = NULL; int type_id = 0; if (0 == bintdi_read_value_rawint(tdi, &type_id)) type = ((struct i_value_factory*)((etch_object*)tdi->vf)->vtab)->get_type_by_id(tdi->vf, type_id); /* note that the type object returned by valuefactory.get_type_by_id * is not disposable, it is a reference into the global types map. * and we are returning that nondisposable reference here */ return type; } /** * bintdi_read_bytearray() * read all bytes from the buffer, return a native array wrapping the resultant byte array * todo: is this OK to return nativearray in one case, and arrayvalue in another? * can we handle the nativearray format across the board? we can at least use nativearray * for byte blobs. even if we use arravalue format we should at least use nativearray * as the base of the arrayvalue, since if we need to be able to access elements, we can't * simply reflect to an array as does java, we need the subscripting of the nativearray. */ etch_nativearray* bintdi_read_bytearray(binary_tagged_data_input* tdi) { int size = 0; etch_nativearray* newarray = NULL; byte* buf = bintdi_read_bytes(tdi, 0, &size); /* buf is disposable, newarray will own it */ newarray = new_etch_nativearray_from(buf, CLASSID_ARRAY_BYTE, sizeof(byte), 1, size, 0, 0); newarray->is_content_owned = TRUE; return newarray; } /** * bintdi_read_string() * read all bytes from the buffer and translate to unicode C string * @return the wrapped string */ etch_string* bintdi_read_string(binary_tagged_data_input* tdi) { int result = 0, size = 0; wchar_t* widestring = NULL; etch_string* newstr = NULL; byte* buf = NULL; const int configured_encoding = tdi->vf? get_etch_string_encoding(tdi->vf): ETCH_ENCODING_DEFAULT; const int nulltermsize = etch_encoding_get_sizeof_terminator(configured_encoding); buf = bintdi_read_bytes(tdi, nulltermsize, &size); /* we own this memory */ if(buf) { // TODO: pool result = etch_encoding_transcode_to_wchar(&widestring, buf, configured_encoding, size, NULL); etch_free(buf); /* construct string object, relinquishing ownership of string buffer */ newstr = new_string_from(widestring, etch_encoding_for_wchar()); } return newstr; } /* - - - - - - - - - - - - - - - - - - - - * read structured content * - - - - - - - - - - - - - - - - - - - - */ /** * bintdi_read_keys_values() * deserializes a message from a buffer. * read all key/value pairs from buffer, populating the specified struct. * @param tdi caller retains. * @param sv caller retains. * @return 0 success, -1 deserialization failed, caller should throw exception. */ int bintdi_read_keys_values (binary_tagged_data_input* tdi, etch_structvalue* sv) { etch_type* svtype = sv->struct_type; etch_validator* thisvtor = NULL; /* non-disposable ref to type vtor */ etch_object* thisobj = NULL; /* disposable return from read_value */ etch_object* thisvalue = NULL; /* disposable return from read_value */ etch_field* key_field = NULL; /* non-disposable ref to static field */ etch_field* key_clone = NULL; /* disposable copy of structvalue key */ etch_int32* this_idobj = NULL; /* non-disposable copy of thisobj */ int result = 0; while(result == 0) { thisobj = bintdi_read_valuex(tdi, tdi->vtor_int, TRUE); /* disposable */ //could not read next key field if(!thisobj) { break; } if (etchtagdata_is_eod (thisobj)) break; /* data end marker found */ key_clone = NULL; thisvalue = NULL; result = -1; this_idobj = (etch_int32*) thisobj; key_field = etchtype_get_field_by_id (svtype, this_idobj->value); if (NULL == key_field) { ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR,"field lookup failed, trying to skip that value\n"); //skip the value of unknown keys... thisvalue = bintdi_read_value(tdi, etchvtor_object_get(0)); /* returns a disposable ref */ //if this fails, we cannot know where we are, so stop if(thisvalue == NULL) { ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR,"cant skip value, error in deserialization\n"); result = -1; break; } else {//else we can continue ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR,"skipped the value for the unknown key\n"); result = 0; continue; } } thisvtor = (etch_validator*) etchtype_get_validator_by_name(svtype, key_field->name); /* returns us a non-disposable ref */ thisvalue = bintdi_read_value(tdi, thisvtor); /* returns a disposable ref */ if (NULL == thisvalue){ break; /* validation or other deserialization error */ } key_clone = (etch_field*)etch_object_clone_func(key_field); /* structvalue_put() expects disposable key and value objects, i.e. it will * call destructors on the objects when the struct is destroyed. however if * the put() fails, we still own the objects, which are accounted for below. * note also that this contract differs from the etch_message interface to * a struct, which eats its put parameters regardless of outcome. */ result = structvalue_put(sv, key_clone, (etch_object*) thisvalue); //printf("read_keys_values: got field %s, value: %p\n",key_clone->aname,thisvalue); /* if put was OK we have relinquished ownership of valuobj */ /* key_field was relinquished regardless. */ etch_object_destroy(thisobj); thisobj = NULL; } if (-1 == result) { /* some error, usually failed validation */ ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR,"message deserialization failed\n"); etch_object_destroy(key_clone); key_clone = NULL; etch_object_destroy(thisvalue); thisvalue = NULL; } etch_object_destroy(thisobj); thisobj = NULL; return result; } /** * bintdi_read_values() * read values from buffer, populating the specified array with the values so read */ int bintdi_read_values (binary_tagged_data_input* tdi, etch_arrayvalue* av, etch_validator* vtor) { int counter = 0; etch_validator* ev = vtor? vtor->element_validator(vtor): NULL; etch_object* thisobj = 0; int result = 0; if (!av || !vtor) return -1; while(result == 0) { thisobj = bintdi_read_valuex(tdi, ev, TRUE); if (NULL == thisobj) return -1; if (etchtagdata_is_eod(thisobj)) break; /* relinquish ownership of thisobj to the arrayvalue */ result = arrayvalue_add(av, thisobj); if (0 == result) thisobj = NULL; counter++; } etch_object_destroy(ev); etch_object_destroy(thisobj); return result; } /* - - - - - - - - - - - - - - - - - - - - * read tokens * - - - - - - - - - - - - - - - - - - - - */ /** * bintdi_read_value() */ etch_object* bintdi_read_value(binary_tagged_data_input* tdi, etch_validator* vtor) { return bintdi_read_valuex(tdi, vtor, FALSE); } /** * bintdi_read_valuex() * reads a tag byte from the buffer, and based on the tag, reads zero or more * bytes from the buffer, appropriate to the data type indicated by the tag. * @return a *disposable* object which appropriately wraps the bytes or object * read from input buffer. however if the data tag indicated a null object, a * nullobj is returned, or if the tag indicated end of data, an eod object is * returned. if validation fails on the object, NULL is returned, otherwise an * object is always returned on which the caller is expected to call destroy(). */ etch_object* bintdi_read_valuex (binary_tagged_data_input* tdi, etch_validator* v, boolean is_none_ok) { /* if this method returns NULL it must first destroy any object created * herein. normally this is accomplished in bintdi_validate_value. */ union_alltypes u; signed char objtype = 0; if (-1 == etch_flexbuf_get_byte (tdi->flexbuf, (byte*)&objtype)) return NULL; switch((signed char)objtype) { case ETCH_XTRNL_TYPECODE_NULL: /* returns the instance null object. it is considered disposable because * caller can and will call destroy() on it. however the destructor will * have no effect, the null object is destroyed in the tdi destructor.*/ return (etch_object*) bintdi_validate_valuex (tdi, v, FALSE, (etch_object*) tdi->static_nullobj); case ETCH_XTRNL_TYPECODE_NONE: /* returns the instance eod object. it is considered disposable because * caller can and will call destroy() on it. however the destructor will * have no effect, the eod object is destroyed in the tdi destructor. */ return bintdi_validate_value(tdi, v, is_none_ok, (etch_object*) tdi->static_eodmarker); case ETCH_XTRNL_TYPECODE_BOOLEAN_FALSE: return bintdi_validate_value (tdi, v, FALSE, (void*) new_boolean(FALSE)); case ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE: return bintdi_validate_value (tdi, v, FALSE, (void*) new_boolean(TRUE)); case ETCH_XTRNL_TYPECODE_BYTE: if (-1 == etch_flexbuf_get_byte(tdi->flexbuf, (byte*)(&u.vbyte))) break; return bintdi_validate_valuex (tdi, v, FALSE, (void*) new_byte(u.vbyte)); case ETCH_XTRNL_TYPECODE_SHORT: if (-1 == etch_flexbuf_get_short(tdi->flexbuf, &u.vint16)) break; return bintdi_validate_valuex (tdi, v, FALSE, (void*) new_int16(u.vint16)); case ETCH_XTRNL_TYPECODE_INT: if (-1 == etch_flexbuf_get_int(tdi->flexbuf, &u.vint32)) break; return bintdi_validate_valuex (tdi, v, FALSE, (void*) new_int32(u.vint32)); case ETCH_XTRNL_TYPECODE_LONG: if (-1 == etch_flexbuf_get_long(tdi->flexbuf, &u.vint64)) break; return bintdi_validate_value (tdi, v, FALSE, (void*) new_int64(u.vint64)); case ETCH_XTRNL_TYPECODE_FLOAT: if (-1 == etch_flexbuf_get_float(tdi->flexbuf, &u.vfloat)) break; return bintdi_validate_value (tdi, v, FALSE, (void*) new_float(u.vfloat)); case ETCH_XTRNL_TYPECODE_DOUBLE: if (-1 == etch_flexbuf_get_double(tdi->flexbuf, &u.vdouble)) break; return bintdi_validate_value(tdi, v, FALSE, (void*) new_double(u.vdouble)); case ETCH_XTRNL_TYPECODE_BYTES: /* must return arrayvalue for symmetry with tdo */ /* todo modify arrayvalue to not populate objects when so requested */ u.vnatarray = bintdi_read_bytearray(tdi); return bintdi_validate_value (tdi, v, FALSE, (void*) u.vnatarray); /* u.varrayval = new_arrayvalue_from(u.vnatarray, ETCH_XTRNL_TYPECODE_BYTES, NULL, (int) u.vnatarray->bytecount, 0, FALSE); return bintdi_validate_value (tdi, v, FALSE, (void*) u.varrayval); */ //return (etch_object*)u.vnatarray; case ETCH_XTRNL_TYPECODE_EMPTY_STRING: return bintdi_validate_value (tdi, v, FALSE, (void*) tdi->static_emptystring); case ETCH_XTRNL_TYPECODE_STRING: u.vstring = bintdi_read_string(tdi); return bintdi_validate_value (tdi, v, FALSE, (void*) u.vstring); case ETCH_XTRNL_TYPECODE_STRUCT: u.vsv = bintdi_read_struct((void*) tdi); return bintdi_validate_value (tdi, v, FALSE, (void*) u.vsv); case ETCH_XTRNL_TYPECODE_ARRAY: u.varrayval = bintdi_read_array((tagged_data_input*) tdi, v); return bintdi_validate_value (tdi, v, FALSE, (void*) u.varrayval); case ETCH_XTRNL_TYPECODE_CUSTOM: { etch_object* reconstituted_object = NULL; /* acquire struct */ etch_structvalue* keys_values = bintdi_read_struct((tagged_data_input*) tdi); //deserialization failed if(! keys_values) { return NULL; } /* relinquish struct */ reconstituted_object = ((struct i_value_factory*)((etch_object*)tdi->vf)->vtab)->import_custom_value(tdi->vf, keys_values); return bintdi_validate_value (tdi, v, FALSE, (void*) reconstituted_object); } default: if (is_inrange_tiny_for_signed_chars(objtype)) return bintdi_validate_valuex (tdi, v, FALSE, (void*) new_byte(objtype)); } return NULL; } /** * bintdi_read_value_rawint() * read an integer value from the buffer, returning the 32-bit primitive * in the out parameter. * @param out a pointer to an int to receive the value read from the buffer. * @return 0 success, -1 if an integer could not be read from the buffer */ int bintdi_read_value_rawint(binary_tagged_data_input* tdi, int* out) { int thisint = 0, result = 0; signed char objtype = 0; union_alltypes u; if (0 != etch_flexbuf_get_byte(tdi->flexbuf, (byte*)&objtype)) result = -1; else if (is_inrange_tiny_for_signed_chars(objtype)) thisint = objtype; else switch(objtype) { case ETCH_XTRNL_TYPECODE_INT: if (0 == (result = etch_flexbuf_get_int(tdi->flexbuf, &u.vint32))) thisint = u.vint32; break; case ETCH_XTRNL_TYPECODE_SHORT: if (0 == (result = etch_flexbuf_get_short(tdi->flexbuf, &u.vint16))) thisint = u.vint16; break; case ETCH_XTRNL_TYPECODE_BYTE: if (0 == (result = etch_flexbuf_get_byte(tdi->flexbuf, (byte*)&u.vbyte))) thisint = u.vbyte; break; default: result = -1; } *out = thisint; return result; } /* - - - - - - - - - - - - - - - - - - - - * utility methods * - - - - - - - - - - - - - - - - - - - - */ /** * bintdi_get_component_type() * * @return etch c obj_type and class_id of an array of specified external type, * and its content, or -1 indicating exception condition. */ int bintdi_get_component_type(tagged_data_input* tdi, const byte array_content_type, etch_type* custom_type, const int dims, etch_array_id_params* out) { if (NULL == out) return -1; memset(out, 0, sizeof(etch_array_id_params)); return bintdi_get_native_type(array_content_type, out); } /* * bintdi_get_native_type() * returns the internal object types and class ids corresponding to the * external byte typecode indicating content type of an array on the wire. * class_id may or may not be significant, depending on particular obj_type. */ int bintdi_get_native_type(const signed char external_typecode, etch_array_id_params* out) { int result = 0; memset(out, 0, sizeof(etch_array_id_params)); out->content_obj_type = ETCHTYPEB_PRIMITIVE; out->array_obj_type = ETCHTYPEB_NATIVEARRAY; switch(external_typecode) { case ETCH_XTRNL_TYPECODE_INT: out->content_class_id = CLASSID_PRIMITIVE_INT32; out->array_class_id = CLASSID_ARRAY_INT32; break; case ETCH_XTRNL_TYPECODE_STRING: case ETCH_XTRNL_TYPECODE_EMPTY_STRING: out->content_class_id = CLASSID_STRING; out->array_class_id = CLASSID_ARRAY_STRING; break; case ETCH_XTRNL_TYPECODE_BYTE: out->content_class_id = CLASSID_PRIMITIVE_BYTE; out->array_class_id = CLASSID_ARRAY_BYTE; break; case ETCH_XTRNL_TYPECODE_LONG: out->content_class_id = CLASSID_PRIMITIVE_INT64; out->array_class_id = CLASSID_ARRAY_INT64; break; case ETCH_XTRNL_TYPECODE_SHORT: out->content_class_id = CLASSID_PRIMITIVE_INT16; out->array_class_id = CLASSID_ARRAY_INT16; break; case ETCH_XTRNL_TYPECODE_DOUBLE: out->content_class_id = CLASSID_PRIMITIVE_DOUBLE; out->array_class_id = CLASSID_ARRAY_DOUBLE; break; case ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE: case ETCH_XTRNL_TYPECODE_BOOLEAN_FALSE: out->content_class_id = CLASSID_PRIMITIVE_BOOL; out->array_class_id = CLASSID_ARRAY_BOOL; break; case ETCH_XTRNL_TYPECODE_FLOAT: out->content_class_id = CLASSID_PRIMITIVE_FLOAT; out->array_class_id = CLASSID_ARRAY_FLOAT; break; case ETCH_XTRNL_TYPECODE_ANY: case ETCH_XTRNL_TYPECODE_ARRAY: case ETCH_XTRNL_TYPECODE_STRUCT: case ETCH_XTRNL_TYPECODE_CUSTOM: case ETCH_XTRNL_TYPECODE_NULL: out->content_obj_type = ETCHTYPEB_ETCHOBJECT; out->content_class_id = CLASSID_OBJECT; out->array_class_id = CLASSID_ARRAY_OBJECT; break; case ETCH_XTRNL_TYPECODE_BYTES: out->content_obj_type = ETCHTYPEB_ARRAYVAL; out->content_class_id = CLASSID_ARRAY_BYTE; out->array_class_id = CLASSID_ARRAY_BYTE; break; default: if (is_inrange_tiny_for_signed_chars(external_typecode)) { out->content_class_id = CLASSID_PRIMITIVE_INT8; out->array_class_id = CLASSID_ARRAY_INT8; } else { out->content_obj_type = ETCHTYPEB_NONE; out->content_class_id = CLASSID_NONE; result = -1; } } return result; } /* * bintagdata_get_native_typecode() * returns the external type code corresponding to internal type. * etchtagdata_get_native_typecode() override */ signed char bintagdata_get_native_typecode (const unsigned short obj_type, const unsigned short class_id) { byte xtype = 0; static const byte primitives[10] = {ETCH_XTRNL_TYPECODE_CUSTOM, /* CLASSID_NONE = 0x0 */ ETCH_XTRNL_TYPECODE_BYTE, /* CLASSID_PRIMITIVE_BYTE = 0x1 */ ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE, /* CLASSID_PRIMITIVE_BOOL = 0x2 */ ETCH_XTRNL_TYPECODE_BYTE, /* CLASSID_PRIMITIVE_INT8 = 0x3 */ ETCH_XTRNL_TYPECODE_SHORT, /* CLASSID_PRIMITIVE_INT16 = 0x4 */ ETCH_XTRNL_TYPECODE_INT, /* CLASSID_PRIMITIVE_INT32 = 0x5 */ ETCH_XTRNL_TYPECODE_LONG, /* CLASSID_PRIMITIVE_INT64 = 0x6 */ ETCH_XTRNL_TYPECODE_FLOAT, /* CLASSID_PRIMITIVE_FLOAT = 0x7 */ ETCH_XTRNL_TYPECODE_DOUBLE, /* CLASSID_PRIMITIVE_DOUBLE = 0x8 */ ETCH_XTRNL_TYPECODE_STRING /* CLASSID_STRING = 0x9 */ }; switch(obj_type) { case ETCHTYPEB_PRIMITIVE: if (class_id <= CLASSID_STRING) xtype = primitives[class_id]; else xtype = ETCH_XTRNL_TYPECODE_CUSTOM; break; case ETCHTYPEB_ETCHOBJECT: xtype = ETCH_XTRNL_TYPECODE_ANY; break; default: xtype = ETCH_XTRNL_TYPECODE_CUSTOM; } return xtype; } /* * bintdi_get_custom_structtype() * override of etchtagdata_get_custom_structtype. * defers to value factory to return a non-disposable struct type * for the specified class. */ etch_type* bintdi_get_custom_structtype(etch_object* thisx, const unsigned short obj_type, const unsigned short class_id) { etch_type *static_type = NULL; binary_tagged_data_input *tdi = (binary_tagged_data_input*) thisx; etch_value_factory *vf = tdi->vf; if(vf) static_type = ((struct i_value_factory*)((etch_object*)vf)->vtab)->get_custom_struct_type(vf, class_id); return static_type; } /** * bintdi_validate_value() * not an override. * &return an object *of the type being validated*, or null. this may be the same * object as the passed value, or may be different. for example if we are working * with an array of int, and a zero value was serialized, it will have been * deserialized into an etch_byte, and the int validator validate_value will * create and return an etch_int32 in its stead. * null return indicates a validation error. null object return indicates value * read was logically null. eod object return indicates end of data. if validation * fails on a object, that object's destructor is invoked here. */ etch_object* bintdi_validate_value (binary_tagged_data_input* tdi, etch_validator* vtor, boolean is_none_ok, etch_object* value) { etch_object* resultobj = NULL; if(! value) return NULL; if (NULL == vtor) { resultobj = NULL; ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR, "no validator for type %x class %x\n", ((etch_object*)value)->obj_type, ((etch_object*)value)->class_id); etch_object_destroy(value); value = NULL; return NULL; } else if (NULL == value) { return NULL; } else if (etchtagdata_is_eod(value) && is_none_ok) { resultobj = value; } else if (etchtagdata_is_null(value) && is_none_ok) { resultobj = value; } else if (NULL == (resultobj = vtor->validate_value (vtor, value))) { ETCH_LOG(LOG_CATEGORY, ETCH_LOG_ERROR, "validation failed for type %x class %x\n", ((etch_object*)value)->obj_type, ((etch_object*)value)->class_id); etch_object_destroy(value); value = NULL; /* todo it would be nice to get an exception back across the wire here * rather than kibosh the session, but not sure what the path would be * to get it there, since we don't have a message yet at this point. */ } /* resultobj may be the same object as value, or may be different. * if value was not an object of the type being validated, i.e. the validator * is the int validator but the value object is an etch_byte representing zero, * resultobj will be an etch_int32. if validation failed resultobj is null. */ return resultobj; } /** * bintdi_validate_valuex() * invokes bintdi_validate_value on a value object, and if the validated object * to be returned is not the same object as the passed value object, that value * object's destructor is invoked. within the tdi, this will not necessarily * destroy the value object, as the tdi can pass protected static objects, * such as an object representing null, for validation. * @return a validated object of the same class as that of the supplied validator, * which may or may not be the same object as the passed value object. */ etch_object* bintdi_validate_valuex(binary_tagged_data_input* tdi, etch_validator* vtor, boolean is_none_ok, etch_object* valueobj) { etch_object* resultobj = bintdi_validate_value(tdi, vtor, is_none_ok, valueobj); if (resultobj && valueobj && (resultobj != valueobj)) etch_object_destroy(valueobj); return resultobj; }