C++ (Cpp) axiom_stax_builder_free Examples

Example #1

File: test_wsdl_data.c Project: kasungayan/commons

void 
create_axiom_from_string(const axutil_env_t* env, axis2_char_t* buffer, axiom_node_t** node)
{
	axiom_xml_reader_t* xml_reader = NULL;
    axiom_document_t* document = NULL;
    axiom_stax_builder_t* om_builder = NULL;
    
	xml_reader = axiom_xml_reader_create_for_memory(env, buffer, strlen(buffer), NULL, AXIS2_XML_PARSER_TYPE_BUFFER); /* encoding ?? */

	if (!xml_reader)
    {
        AXIS2_LOG_ERROR_MSG(env->log, "[wsf_wsdl_test]Failed to create wsdl_xml_reader\n");
        return;
    }

    om_builder = axiom_stax_builder_create(env, xml_reader);
    if (!om_builder)
    {
        AXIS2_LOG_ERROR_MSG(env->log, "[wsf_wsdl_test]Failed to create wsdl stax builder\n");
        axiom_xml_reader_free(xml_reader, env);
        return;
    }
    
    document = axiom_stax_builder_get_document(om_builder, env);
    if (!document)
    {
        AXIS2_LOG_ERROR_MSG(env->log, "[wsf_wsdl_test]Failed to get retrieve wsdl document\n");
        axiom_stax_builder_free(om_builder, env);
        return;
    }        
   
    *node = axiom_document_build_all(document, env);

	return;
}

Example #2

File: type_map.c Project: kasungayan/commons

WSF_WSDL_EXTERN axis2_bool_t WSF_WSDL_CALL 
wsdl_util_create_type_map(
    const axutil_env_t* env, 
    axis2_char_t* type_map_xml_file, 
    axiom_node_t** type_map)
{
    axiom_xml_reader_t* typemap_xml_reader = NULL;
    axiom_document_t* typemap_document = NULL;
    axiom_stax_builder_t* typemap_om_builder = NULL;

    typemap_xml_reader = axiom_xml_reader_create_for_file(env, type_map_xml_file, NULL); /* encoding ?? */
    if (!typemap_xml_reader)
    {
        AXIS2_LOG_ERROR_MSG(env->log, "Failed to create xml reader for typemap");
        return AXIS2_FAILURE;
    }

    typemap_om_builder = axiom_stax_builder_create(env, typemap_xml_reader);
    if (!typemap_om_builder)
    {
        AXIS2_LOG_ERROR_MSG(env->log, "Failed to create om builder for typemap");
        axiom_xml_reader_free(typemap_xml_reader, env);
        return AXIS2_FAILURE;
    }
    
    typemap_document = axiom_stax_builder_get_document(typemap_om_builder, env);
    if (!typemap_document)
    {
        AXIS2_LOG_ERROR_MSG(env->log, "Failed to create document for typemap");
        axiom_stax_builder_free(typemap_om_builder, env);
        return AXIS2_FAILURE;
    }        
   
    *type_map = axiom_document_build_all(typemap_document, env);
     
    axiom_stax_builder_free_self(typemap_om_builder, env); 
    
    return AXIS2_SUCCESS;
}

Example #3

File: main.c Project: Denisss025/wsfcpp

axiom_node_t *
return_policy_element(
    axis2_char_t * name,
    const axutil_env_t * env,
    axis2_char_t * wsdl_name)
{
    axiom_element_t *ele1 = NULL,
        *ele2 = NULL;
    axiom_document_t *document = NULL;
    axiom_node_t *node1 = NULL,
        *node2 = NULL,
        *policy_node = NULL;
    axiom_namespace_t *ns = NULL;
    axiom_xml_reader_t *reader = NULL;
    axiom_stax_builder_t *builder = NULL;
    char *buffer = NULL;
    axiom_attribute_t *attr = NULL;
    axis2_char_t *value = NULL;
    axis2_char_t *val = NULL;
    axutil_hash_t *attr_hash = NULL;
    axis2_char_t *xml_output = NULL;
    axutil_hash_index_t *hi;

/*
    f = fopen(wsdl_name, "r");
    if (!f)
        return NULL;

    reader = axiom_xml_reader_create_for_io(env, read_input, NULL , NULL, NULL);
*/
    reader = axiom_xml_reader_create_for_file(env, wsdl_name, NULL);

    if (!reader)
    {
        printf("ERROR CREATING PULLPARSER");
        return NULL;
    }

    builder = axiom_stax_builder_create(env, reader);

    if (!builder)
    {
        printf("ERROR CREATING PULL PARSER");
        return NULL;
    }

    document = axiom_stax_builder_get_document(builder, env);
    if (!document)
        return NULL;

    node1 = axiom_document_get_root_element(document, env);
    if (!node1)
    {
        printf(" root element null ");
        axiom_stax_builder_free(builder, env);
        return NULL;
    }

    do
    {
        node2 = axiom_document_build_next(document, env);

        if (!node2)
            break;

        if (axiom_node_get_node_type(node2, env) == AXIOM_ELEMENT)
        {
            ele2 = (axiom_element_t *) axiom_node_get_data_element(node2, env);
            attr_hash = axiom_element_get_all_attributes(ele2, env);
            if (attr_hash)
            {
                hi = axutil_hash_first(attr_hash, env);
                axutil_hash_this(hi, NULL, NULL, &attr);

                if (axutil_strcmp(axiom_attribute_get_value(attr, env), name) ==
                    0)
                {
                    policy_node = node2;
                }
            }
        }
    }
    while (node2);
    return policy_node;
}