Hi Josef,
I have two suggestion for your plea.
1. You should consider calling axiom_stax_builder_free() instead of
axiom_document_free(). As the stax_builder is responsible for the returned
document.
2. Consider duplicating the strings before copying to (or from) your hash.
You can use axutil_strdup() for this purpose.
NOTE: duplicating strings allocate new memory. Please be responsible to
free allocated memory to avoid leaks.
AFAIK, according to what you describe, this doesn't seem to be a bug.
Regards,
Senaka
> Hi Developers,
>
> I use Apache Axis2/C version 1.0.0, ported to OopenVMS, also used on
> Windows 2000
> under VS 2005 (C/C++); so far greate stuff.
>
> Now I have the follwoing problem and I think it is a bug in Axis2/C
>
> I have to deserialize my payload (build om from xml) and return to updated
> pointers
> to two hash tables, each keeping a set of fldnam (key) and fldval
> (val->value) pairs.
>
> The xml payload to be converted into an om model looks like this
>
> <root xmlns:e="element" xmlns:ws="workspace" xmlns:col="collection">
> <col:wscol>
> <ws:wsinp>
> <e:blah01>yuck01</e:blah01>
> <e:blah02>yuck02</e:blah02>
> <e:blah03>yuck03</e:blah03>
> <e:blah04>yuck04</e:blah04>
> </ws:wsinp>
> <ws:wsold>
> <e:blah11>yuck11</e:blah11>
> <e:blah12>yuck12</e:blah12>
> <e:blah13>yuck13</e:blah13>
> <e:blah14>yuck14</e:blah14>
> </ws:wsold>
> </col:wscol>
> </root>
>
> The clue is that I can iterate over the hash tables and find my key/value
> pairs but only
> as long as I do not execute axiom_document_free(om_document,env); as
> done in code below.
>
> Once this call is executed, pointers to hash tables are still as before,
> but content, key
> and value pairs are gone, do no longer exist, and my routine writes out
> some rubbish. why?
>
> I asume this is a bug OR do I something wrong allocating storage for the
> hash tables
> key / value pairs?
>
> What has to be released from memeory (deallocated), I guess only the om
> model as I want
> it but not the key and values of my hash tables.
>
> And BTW, if one knows a faster way to deserialize my payload as I do it,
> just let me know.
> I will be very thank-full, because I am still a xml/om newby.
>
> Thanks for information and regards
>
>
>
> axis2_bool_t AXIS2_CALL
> axawl_deserialize_input_payload(axutil_env_t *env,
> const
> axis2_char_t *payload_inp,
> const
> axutil_hash_t **pphtwsinp,
> const
> axutil_hash_t **pphtwsold)
> {
> int retval = 0;
> unsigned __int16 scnt;
> char *tval2;
> long ii;
>
> const axis2_char_t *encoding = ENCODING; //#define
> ENCODING "ISO-8859-1"
> // const axis2_char_t *uri = AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI;
>
>
> axiom_xml_reader_t *xml_reader = NULL;
> axiom_stax_builder_t *om_builder = NULL;
> axiom_document_t *om_document = NULL;
> axiom_node_t *root_node = NULL;
>
> axiom_node_t *body = NULL;
> axiom_node_t *root = NULL;
> axiom_node_t *wscol = NULL;
> axiom_node_t *ws = NULL;
> axiom_node_t *wsinp = NULL;
> axiom_node_t *wsold = NULL;
> axiom_node_t *wsout = NULL;
> axiom_node_t *ele = NULL;
>
> axiom_children_qname_iterator_t *children_iter = NULL;
>
> axis2_char_t *fldnam = NULL;
> a *fldval = NULL;
>
> const void *key = NULL;
> void *val = NULL;
> axutil_hash_index_t *hi;
> axutil_hash_t *htwsinp = NULL;
> axutil_hash_t *htwsold = NULL;
>
> int status = AXIS2_SUCCESS;
>
> env->log->level = AXIS2_LOG_LEVEL_DEBUG;
> AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, " %s %d", "deserialize input
> payload", 2);
>
> scnt = strlen(payload_inp);
>
> /** create the parser ---- here we feed our P1 parameter = the input
> argument in string form */
> xml_reader = axiom_xml_reader_create_for_memory(env, payload_inp,
> scnt, encoding, AXIS2_XML_PARSER_TYPE_BUFFER);
> if (!xml_reader) {
> printf("%s \n", axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s",
> axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create
> xml_reader");
> return AXIS2_FAILURE;
> }
>
> om_builder = axiom_stax_builder_create(env, xml_reader);
> if (!om_builder) {
> axiom_xml_reader_free(xml_reader, env);
> printf("%s \n", axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s",
> axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create
> om_builder - ERROR CREATING PULLPARSER");
> return AXIS2_FAILURE;
> }
>
> /**
> create an om document
> document is the container of om model created using builder
> */
> om_document = axiom_stax_builder_get_document(om_builder, env);
> if (!om_document) {
> axiom_xml_reader_free(xml_reader, env);
> printf("%s \n", axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s",
> axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create
> axiom document");
> return AXIS2_FAILURE;
> }
>
> root_node = axiom_document_get_root_element(om_document, env);
> if(!root_node)
> {
> axiom_stax_builder_free(om_builder, env);
> printf("%s \n", axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s",
> axutil_error_get_message(env->error));
> AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s", "unable to create
> root node from om_document");
> return AXIS2_FAILURE;
> }
>
> #ifdef __DEBUG__
> lib$signal(SS$_DEBUG);
> #endif
> /**
> Pseudo Code to reflect what shall happen
> for each wscol in soap_body
> // we get c:root only
> for each ws in wscol
> // we get c:Text c:wsout c:wsold c:wsinp
> for each ele in ws
> // we get d:fldnam with fldval as text
> next ele
> next ws
> next
> **/
>
> /**
> pre-condition: we have the document with the OM model in it
>
> action: we loop over the (sub-)tree and isolates the workspace
> collection, the workpsaces and
> the elements in it. workspace nodes are used to identify and create a
> corresponding hash table
> and then all elements in the workspace-node are loaded as key and
> value pairs to hash tables
>
> post-condition: after the loop terminates, we have hash tables
> established and tow are populated
> with key-value-pairs of strings; we have a hash table for wsinp, wsold
> and later wsout and htGWKSP
> But htwsout and htGWKSP are not established here as the intention of the
> code is jsut to deserialize
> for ws input and ws old (used to establish the process context, set
> process context to previous state
> when client calls in again)
> **/
>
>
> // for (root = axiom_soap_body_get_base_node(soap_body, env);root;root =
> axiom_node_get_next_sibling(root, env)) {
> for (root = axiom_document_get_root_element(om_document,
> env);root;root = axiom_node_get_next_sibling(root, env)) {
> putnode(root, env);
> for (wscol = axiom_node_get_first_child(root, env);wscol;wscol =
> axiom_node_get_next_sibling(wscol, env)) {
> putnode(wscol, env);
> for (ws = axiom_node_get_first_child(wscol, env);ws; ws =
> axiom_node_get_next_sibling(ws, env)) {
> putnode(ws, env);
> for (ele = axiom_node_get_first_child(ws, env);ele;ele =
> axiom_node_get_next_sibling(ele, env)) {
> switch (getWorkspaceID(ele, env)) {
> case 1:
> if(!wsinp)
> wsinp = ws;
> if (!htwsinp)
> htwsinp = axutil_hash_make(env);
> fldval = (a *) AXIS2_MALLOC(env->allocator,
> sizeof(a));
> fldval->value = getFLDVAL(ele, env);
> fldnam = getFLDNAM(ele, env);
> printf("\nfldval->value
> : %s",fldval->value);
> printf("\nfldnam
> : %s",fldnam);
> axutil_hash_set(htwsinp, fldnam,
> AXIS2_HASH_KEY_STRING, fldval);
> break;
> case 2:
> if(!wsold)
> wsold = ws;
> if (!htwsold)
> htwsold = axutil_hash_make(env);
> fldval = (a *) AXIS2_MALLOC(env->allocator,
> sizeof(a));
> fldval->value = getFLDVAL(ele, env);
> fldnam = getFLDNAM(ele, env);
> printf("\nfldval->value
> : %s",fldval->value);
> printf("\nfldnam
> : %s",fldnam);
> axutil_hash_set(htwsold, fldnam,
> AXIS2_HASH_KEY_STRING, fldval);
> break;
> default:
> break;
> }
> }
> }
> }
> }
>
> for (hi = axutil_hash_first(htwsinp, env); hi; hi =
> axutil_hash_next(env,
> hi)) {
> axutil_hash_this(hi, &key, NULL, &val);
> printf("\nkey\t: %s", key);
> printf("\tval\t: %s", ((a *) val)->value);
> }
> /**
> QUESTION: do we need the parsed in document and om model any
> longer?
> NO - we can safely free all of it, memory space and we create a
> new
> om_document with om as root wscol ws and elements in it later,
> after
> the warpper returns.
> **/
> axiom_document_free(om_document,env);
>
> for (hi = axutil_hash_first(htwsinp, env); hi; hi =
> axutil_hash_next(env,
> hi)) {
> axutil_hash_this(hi, &key, NULL, &val);
> printf("\nkey\t: %s", key);
> printf("\tval\t: %s", ((a *) val)->value);
> }
>
> /**
> let us update all our hash_table_pointers to use the
> hash_tables after
> we
> return to the caller of this routine.
> **/
> *pphtwsinp = htwsinp;
> *pphtwsold = htwsold;
>
> return AXIS2_SUCCESS;
> }
>
>
>
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
