axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r496572 [4/5] - in /webservices/axis2/trunk/c: axiom/include/ axiom/src/soap/ util/include/
Date Tue, 16 Jan 2007 02:09:51 GMT
Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c?view=diff&rev=496572&r1=496571&r2=496572
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault.c Mon Jan 15 18:09:50 2007
@@ -28,23 +28,20 @@
 #include <axiom_soap_fault_node.h>
 #include <axiom_soap_builder.h>
 
-/**************** impl struct ************************************************/
-
-typedef struct axiom_soap_fault_impl_t
+struct axiom_soap_fault
 {
-    axiom_soap_fault_t soap_fault;
-    /* om element node corresponding to soap fault */
+    /* om element node corresponding to soap soap_fault */
     axiom_node_t *om_ele_node;
 
-    /* soap fault code sub element */
+    /* soap soap_fault code sub element */
     axiom_soap_fault_code_t *fcode;
-    /* soap fault reason sub element */
+    /* soap soap_fault reason sub element */
     axiom_soap_fault_reason_t *freason;
-    /* soap fault node sub element */
+    /* soap soap_fault node sub element */
     axiom_soap_fault_node_t *fnode;
-    /* soap fault role sub element */
+    /* soap soap_fault role sub element */
     axiom_soap_fault_role_t *frole;
-    /* soap fault detail sub element */
+    /* soap soap_fault detail sub element */
     axiom_soap_fault_detail_t *fdetail;
 
     axis2_char_t *exception;
@@ -52,125 +49,30 @@
     axiom_soap_builder_t *soap_builder;
 
     int soap_version;
-
-}
-axiom_soap_fault_impl_t;
-
-/************************* Macro **********************************************/
-
-#define AXIS2_INTF_TO_IMPL(fault) ((axiom_soap_fault_impl_t*)fault)
-
-/************************ function prototype **********************************/
-
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_free(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-
-
-axiom_soap_fault_code_t * AXIS2_CALL
-axiom_soap_fault_get_code(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-
-
-axiom_soap_fault_reason_t* AXIS2_CALL
-axiom_soap_fault_get_reason(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-
-
-axiom_soap_fault_node_t* AXIS2_CALL
-axiom_soap_fault_get_node(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-axiom_soap_fault_role_t* AXIS2_CALL
-axiom_soap_fault_get_role(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-
-axiom_soap_fault_detail_t* AXIS2_CALL
-axiom_soap_fault_get_detail(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-
-
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_get_base_node(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-
-axis2_char_t * AXIS2_CALL
-axiom_soap_fault_get_exception(axiom_soap_fault_t *fault,
-        const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_exception(axiom_soap_fault_t *fault,
-        const axis2_env_t *env,
-        axis2_char_t *exception);
-
-/***************** function implementations ***********************************/
+};
 
 AXIS2_EXTERN axiom_soap_fault_t * AXIS2_CALL
 axiom_soap_fault_create(const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
+    axiom_soap_fault_t *soap_fault = NULL;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_impl = (axiom_soap_fault_impl_t*)AXIS2_MALLOC(
-                env->allocator,
-                sizeof(axiom_soap_fault_impl_t));
-    if (!fault_impl)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;
-    }
-    fault_impl->exception = NULL;
-    fault_impl->fcode = NULL;
-    fault_impl->fdetail = NULL;
-    fault_impl->fnode = NULL;
-    fault_impl->freason = NULL;
-    fault_impl->frole = NULL;
-    fault_impl->om_ele_node = NULL;
-    fault_impl->soap_fault.ops = NULL;
-    fault_impl->soap_builder = NULL;
-    fault_impl->soap_fault.ops = (axiom_soap_fault_ops_t*)AXIS2_MALLOC(
+    soap_fault = (axiom_soap_fault_t*)AXIS2_MALLOC(
                 env->allocator,
-                sizeof(axiom_soap_fault_ops_t));
-
-    if (!(fault_impl->soap_fault.ops))
+                sizeof(axiom_soap_fault_t));
+    if (!soap_fault)
     {
-        AXIS2_FREE(env->allocator, fault_impl);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-
-    fault_impl->soap_fault.ops->free_fn =
-        axiom_soap_fault_free;
-
-    fault_impl->soap_fault.ops->get_base_node =
-        axiom_soap_fault_get_base_node;
-
-    fault_impl->soap_fault.ops->get_code =
-        axiom_soap_fault_get_code;
-
-    fault_impl->soap_fault.ops->get_reason =
-        axiom_soap_fault_get_reason;
-
-    fault_impl->soap_fault.ops->get_role =
-        axiom_soap_fault_get_role;
-
-    fault_impl->soap_fault.ops->get_node =
-        axiom_soap_fault_get_node;
-
-    fault_impl->soap_fault.ops->get_detail =
-        axiom_soap_fault_get_detail;
-
-    fault_impl->soap_fault.ops->get_exception =
-        axiom_soap_fault_get_exception;
-    fault_impl->soap_fault.ops->set_exception =
-        axiom_soap_fault_set_exception;
-    return &(fault_impl->soap_fault);
+    soap_fault->exception = NULL;
+    soap_fault->fcode = NULL;
+    soap_fault->fdetail = NULL;
+    soap_fault->fnode = NULL;
+    soap_fault->freason = NULL;
+    soap_fault->frole = NULL;
+    soap_fault->om_ele_node = NULL;
+    soap_fault->soap_builder = NULL;
+    return soap_fault;
 }
 
 
@@ -178,8 +80,7 @@
 axiom_soap_fault_create_with_parent(const axis2_env_t *env,
         axiom_soap_body_t *body)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
-    axiom_soap_fault_t *fault = NULL;
+    axiom_soap_fault_t *soap_fault = NULL;
     axiom_element_t *this_ele = NULL;
     axiom_node_t *this_node = NULL;
     axiom_node_t *parent_node = NULL;
@@ -189,25 +90,24 @@
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, body, NULL);
 
-    fault = axiom_soap_fault_create(env);
-    if (!fault)
+    soap_fault = axiom_soap_fault_create(env);
+    if (!soap_fault)
         return NULL;
 
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
     parent_node = AXIOM_SOAP_BODY_GET_BASE_NODE(body, env);
     if (!parent_node)
     {
-        AXIS2_FREE(env->allocator, fault_impl);
+        AXIS2_FREE(env->allocator, soap_fault);
         return NULL;
     }
-    fault_impl->soap_version =
+    soap_fault->soap_version =
         AXIOM_SOAP_BODY_GET_SOAP_VERSION(body, env);
 
     parent_ele  = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
                 parent_node, env);
     if (!parent_ele)
     {
-        AXIS2_FREE(env->allocator, fault_impl);
+        AXIS2_FREE(env->allocator, soap_fault);
         return NULL;
     }
     parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
@@ -219,13 +119,13 @@
             &this_node);
     if (!this_ele)
     {
-        AXIS2_FREE(env->allocator, fault_impl);
+        AXIS2_FREE(env->allocator, soap_fault);
         return NULL;
     }
 
-    fault_impl->om_ele_node = this_node;
-    axiom_soap_body_set_fault(body, env, fault);
-    return  &(fault_impl->soap_fault);
+    soap_fault->om_ele_node = this_node;
+    axiom_soap_body_set_fault(body, env, soap_fault);
+    return  soap_fault;
 }
 
 
@@ -234,357 +134,305 @@
         axiom_soap_body_t *body,
         axis2_char_t* exception)
 {
-    axiom_soap_fault_t *fault = NULL;
+    axiom_soap_fault_t *soap_fault = NULL;
     axis2_status_t status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
     AXIS2_PARAM_CHECK(env->error, body, NULL);
     AXIS2_PARAM_CHECK(env->error, exception, NULL);
-    fault = axiom_soap_fault_create_with_parent(env, body);
-    if (!fault)
+    soap_fault = axiom_soap_fault_create_with_parent(env, body);
+    if (!soap_fault)
         return NULL;
-    status = axiom_soap_fault_set_exception(fault, env, exception);
+    status = axiom_soap_fault_set_exception(soap_fault, env, exception);
     if (status == AXIS2_FAILURE)
     {
-        axiom_soap_fault_free(fault, env);
+        axiom_soap_fault_free(soap_fault, env);
         return NULL;
     }
-    return fault;
+    return soap_fault;
 }
 
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_free(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_free(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
 
-    if (fault_impl->fcode)
-    {
-        AXIOM_SOAP_FAULT_CODE_FREE(fault_impl->fcode, env);
-        fault_impl->fcode = NULL;
-    }
-    if (fault_impl->fdetail)
+    if (soap_fault->fcode)
     {
-        AXIOM_SOAP_FAULT_DETAIL_FREE(fault_impl->fdetail, env);
-        fault_impl->fdetail = NULL;
+        AXIOM_SOAP_FAULT_CODE_FREE(soap_fault->fcode, env);
+        soap_fault->fcode = NULL;
     }
-    if (fault_impl->fnode)
+    if (soap_fault->fdetail)
     {
-        AXIOM_SOAP_FAULT_NODE_FREE(fault_impl->fnode, env);
-        fault_impl->fnode = NULL;
+        AXIOM_SOAP_FAULT_DETAIL_FREE(soap_fault->fdetail, env);
+        soap_fault->fdetail = NULL;
     }
-    if (fault_impl->freason)
+    if (soap_fault->fnode)
     {
-        AXIOM_SOAP_FAULT_REASON_FREE(fault_impl->freason, env);
-        fault_impl->freason = NULL;
+        AXIOM_SOAP_FAULT_NODE_FREE(soap_fault->fnode, env);
+        soap_fault->fnode = NULL;
     }
-    if (fault_impl->frole)
+    if (soap_fault->freason)
     {
-        AXIOM_SOAP_FAULT_ROLE_FREE(fault_impl->frole, env);
-        fault_impl->frole = NULL;
+        AXIOM_SOAP_FAULT_REASON_FREE(soap_fault->freason, env);
+        soap_fault->freason = NULL;
     }
-    if (fault->ops)
+    if (soap_fault->frole)
     {
-        AXIS2_FREE(env->allocator, fault->ops);
-        fault->ops = NULL;
+        AXIOM_SOAP_FAULT_ROLE_FREE(soap_fault->frole, env);
+        soap_fault->frole = NULL;
     }
-    AXIS2_FREE(env->allocator, fault_impl);
-    fault_impl = NULL;
+    AXIS2_FREE(env->allocator, soap_fault);
+    soap_fault = NULL;
     return AXIS2_SUCCESS;
 }
-/**
- This is an internal function, and should only be used by soap
- builder and builder helpers
-*/
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_code(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_code(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axiom_soap_fault_code_t *code)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, code, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (!(fault_impl->fcode))
+    if (!(soap_fault->fcode))
     {
-        fault_impl->fcode = code;
+        soap_fault->fcode = code;
         return AXIS2_SUCCESS;
     }
     else
     {
         AXIS2_LOG_DEBUG(env->log,
-                AXIS2_LOG_SI, "tring to set multiple code elements to fault ");
+                AXIS2_LOG_SI, "tring to set multiple code elements to soap_fault ");
 
     }
     return AXIS2_SUCCESS;
 }
 
-axiom_soap_fault_code_t * AXIS2_CALL
-axiom_soap_fault_get_code(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axiom_soap_fault_code_t * AXIS2_CALL
+axiom_soap_fault_get_code(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (fault_impl->fcode)
+    if (soap_fault->fcode)
     {
-        return fault_impl->fcode;
+        return soap_fault->fcode;
     }
-    else if (fault_impl->soap_builder)
+    else if (soap_fault->soap_builder)
     {
-        while (!(fault_impl->fcode) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while (!(soap_fault->fcode) && !(AXIOM_NODE_IS_COMPLETE(soap_fault->om_ele_node, env)))
         {
-            status = AXIOM_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
+            status = AXIOM_SOAP_BUILDER_NEXT(soap_fault->soap_builder, env);
             if (status == AXIS2_FAILURE)
                 break;
         }
     }
-    return fault_impl->fcode;
+    return soap_fault->fcode;
 }
-/**
-    internal function
-    to be used by soap builder only
-
-*/
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_reason(axiom_soap_fault_t *fault,
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_reason(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axiom_soap_fault_reason_t *reason)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, reason, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (!(fault_impl->freason))
+    if (!(soap_fault->freason))
     {
-        fault_impl->freason = reason;
+        soap_fault->freason = reason;
         return AXIS2_SUCCESS;
     }
     else
     {
         AXIS2_LOG_DEBUG(env->log,
-                AXIS2_LOG_SI, "tring to set fault reason twice");
+                AXIS2_LOG_SI, "tring to set soap_fault reason twice");
     }
     return AXIS2_FAILURE;
 }
 
-axiom_soap_fault_reason_t* AXIS2_CALL
-axiom_soap_fault_get_reason(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axiom_soap_fault_reason_t* AXIS2_CALL
+axiom_soap_fault_get_reason(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (fault_impl->freason)
+    if (soap_fault->freason)
     {
-        return fault_impl->freason;
+        return soap_fault->freason;
     }
-    else if (fault_impl->soap_builder)
+    else if (soap_fault->soap_builder)
     {
-        while (!(fault_impl->freason) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while (!(soap_fault->freason) && !(AXIOM_NODE_IS_COMPLETE(soap_fault->om_ele_node, env)))
         {
-            status = AXIOM_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
+            status = AXIOM_SOAP_BUILDER_NEXT(soap_fault->soap_builder, env);
             if (status == AXIS2_FAILURE)
                 break;
         }
     }
-    return fault_impl->freason;
+    return soap_fault->freason;
 }
-/**
-    internal function
-    to be used by soap builders only
 
-*/
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_node(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_node(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axiom_soap_fault_node_t *node)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (!(fault_impl->fnode))
+    if (!(soap_fault->fnode))
     {
-        fault_impl->fnode = node;
+        soap_fault->fnode = node;
         return AXIS2_SUCCESS;
     }
     else
     {
         AXIS2_LOG_DEBUG(env->log,
-                AXIS2_LOG_SI, "tring to set fault node more than once");
+                AXIS2_LOG_SI, "tring to set soap_fault node more than once");
     }
     return AXIS2_FAILURE;
 }
 
-axiom_soap_fault_node_t* AXIS2_CALL
-axiom_soap_fault_get_node(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axiom_soap_fault_node_t* AXIS2_CALL
+axiom_soap_fault_get_node(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
 
-    if (fault_impl->fnode)
+    if (soap_fault->fnode)
     {
-        return fault_impl->fnode;
+        return soap_fault->fnode;
     }
-    else if (fault_impl->soap_builder)
+    else if (soap_fault->soap_builder)
     {
-        while (!(fault_impl->fnode) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while (!(soap_fault->fnode) && !(AXIOM_NODE_IS_COMPLETE(soap_fault->om_ele_node, env)))
         {
-            status = AXIOM_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
+            status = AXIOM_SOAP_BUILDER_NEXT(soap_fault->soap_builder, env);
             if (status == AXIS2_FAILURE)
                 break;
         }
     }
-    return fault_impl->fnode;
+    return soap_fault->fnode;
 }
-/**
-    internal function to
-    be used by soap builder only
-
-*/
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_role(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_role(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axiom_soap_fault_role_t *role)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, role, AXIS2_FAILURE);
 
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (!(fault_impl->frole))
+    if (!(soap_fault->frole))
     {
-        fault_impl->frole = role;
+        soap_fault->frole = role;
         return AXIS2_FAILURE;
     }
     else
     {
         AXIS2_LOG_DEBUG(env->log,
-                AXIS2_LOG_SI, "tring to set fault role more than once ");
+                AXIS2_LOG_SI, "tring to set soap_fault role more than once ");
     }
     return AXIS2_FAILURE;
 
 }
 
-axiom_soap_fault_role_t* AXIS2_CALL
-axiom_soap_fault_get_role(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axiom_soap_fault_role_t* AXIS2_CALL
+axiom_soap_fault_get_role(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (fault_impl->frole)
+    if (soap_fault->frole)
     {
-        return fault_impl->frole;
+        return soap_fault->frole;
     }
-    else if (fault_impl->soap_builder)
+    else if (soap_fault->soap_builder)
     {
-        while (!(fault_impl->frole) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while (!(soap_fault->frole) && !(AXIOM_NODE_IS_COMPLETE(soap_fault->om_ele_node, env)))
         {
-            status = AXIOM_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
+            status = AXIOM_SOAP_BUILDER_NEXT(soap_fault->soap_builder, env);
             if (status == AXIS2_FAILURE)
                 break;
         }
     }
-    return fault_impl->frole;
+    return soap_fault->frole;
 }
-/**
-    internal function
-    to be used by soap builders only
-*/
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_detail(axiom_soap_fault_t *fault,
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_detail(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axiom_soap_fault_detail_t *detail)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, detail, AXIS2_FAILURE);
 
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (!(fault_impl->fdetail))
+    if (!(soap_fault->fdetail))
     {
-        fault_impl->fdetail = detail;
+        soap_fault->fdetail = detail;
         return AXIS2_SUCCESS;
     }
     else
     {
         AXIS2_LOG_DEBUG(env->log,
-                AXIS2_LOG_SI, " tring to set fault detail more than once");
+                AXIS2_LOG_SI, " tring to set soap_fault detail more than once");
 
     }
     return AXIS2_FAILURE;
 }
 
-axiom_soap_fault_detail_t* AXIS2_CALL
-axiom_soap_fault_get_detail(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axiom_soap_fault_detail_t* AXIS2_CALL
+axiom_soap_fault_get_detail(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    if (fault_impl->fdetail)
+    if (soap_fault->fdetail)
     {
-        return fault_impl->fdetail;
+        return soap_fault->fdetail;
     }
-    else if (fault_impl->soap_builder)
+    else if (soap_fault->soap_builder)
     {
-        while (!(fault_impl->fdetail) && !(AXIOM_NODE_IS_COMPLETE(fault_impl->om_ele_node, env)))
+        while (!(soap_fault->fdetail) && !(AXIOM_NODE_IS_COMPLETE(soap_fault->om_ele_node, env)))
         {
-            status = AXIOM_SOAP_BUILDER_NEXT(fault_impl->soap_builder, env);
+            status = AXIOM_SOAP_BUILDER_NEXT(soap_fault->soap_builder, env);
             if (status == AXIS2_FAILURE)
                 break;
         }
     }
-    return fault_impl->fdetail;
+    return soap_fault->fdetail;
 }
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_base_node(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_base_node(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axiom_node_t *node)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
 
     if (AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    fault_impl->om_ele_node = node;
+    soap_fault->om_ele_node = node;
     return AXIS2_SUCCESS;
 
 }
 
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_get_base_node(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
+axiom_soap_fault_get_base_node(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(fault)->om_ele_node;
+    return soap_fault->om_ele_node;
 }
 
 
-axis2_char_t * AXIS2_CALL
-axiom_soap_fault_get_exception(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_char_t * AXIS2_CALL
+axiom_soap_fault_get_exception(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
     axiom_soap_fault_detail_t *detail = NULL;
@@ -596,7 +444,7 @@
     axis2_char_t *excep = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
-    detail = axiom_soap_fault_get_detail(fault, env);
+    detail = axiom_soap_fault_get_detail(soap_fault, env);
     if (!detail)
         return NULL;
     detail_node = AXIOM_SOAP_FAULT_DETAIL_GET_BASE_NODE(detail, env);
@@ -623,12 +471,11 @@
     return NULL;
 }
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_exception(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_exception(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axis2_char_t *exception)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     axiom_soap_fault_detail_t *detail = NULL;
     axiom_node_t *fault_detail_entry_node = NULL;
     axiom_element_t *fault_detail_ele = NULL;
@@ -637,13 +484,11 @@
 
     AXIS2_PARAM_CHECK(env->error, exception, AXIS2_FAILURE);
 
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-
-    detail = axiom_soap_fault_get_detail(fault, env);
+    detail = axiom_soap_fault_get_detail(soap_fault, env);
 
     if (!detail)
     {
-        detail = axiom_soap_fault_detail_create_with_parent(env, fault);
+        detail = axiom_soap_fault_detail_create_with_parent(env, soap_fault);
         if (!detail)
             return AXIS2_FAILURE;
     }
@@ -659,19 +504,17 @@
     /** set the exception string as a text node of newly created om element */
     AXIOM_ELEMENT_SET_TEXT(fault_detail_ele,
             env, exception, fault_detail_entry_node);
-    /** now add this om element as a child of soap fault detail om element node */
+    /** now add this om element as a child of soap soap_fault detail om element node */
     return AXIOM_SOAP_FAULT_DETAIL_ADD_DETAIL_ENTRY(detail, env, fault_detail_entry_node);
 }
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_builder(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_builder(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         axiom_soap_builder_t *builder)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_PARAM_CHECK(env->error, builder, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    fault_impl->soap_builder = builder;
+    soap_fault->soap_builder = builder;
     return AXIS2_SUCCESS;
 }
 
@@ -764,24 +607,21 @@
     return soap_fault;
 }
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_set_soap_version(axiom_soap_fault_t *fault,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_set_soap_version(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env,
         int soap_version)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    fault_impl->soap_version = soap_version;
+    soap_fault->soap_version = soap_version;
     return AXIS2_SUCCESS;
 }
 
-int AXIS2_CALL
-axiom_soap_fault_get_soap_version(axiom_soap_fault_t *fault,
+AXIS2_EXTERN int AXIS2_CALL
+axiom_soap_fault_get_soap_version(axiom_soap_fault_t *soap_fault,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_impl_t *fault_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_impl = AXIS2_INTF_TO_IMPL(fault);
-    return fault_impl->soap_version;
+    return soap_fault->soap_version;
 }
+

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c?view=diff&rev=496572&r1=496571&r2=496572
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_code.c Mon Jan 15 18:09:50 2007
@@ -21,12 +21,8 @@
 #include <axiom_soap_builder.h>
 #include "_axiom_soap_fault.h"
 
-/***************** impl struct ***********************************************/
-
-typedef struct axiom_soap_fault_code_impl_t
+struct axiom_soap_fault_code
 {
-    axiom_soap_fault_code_t fault_code;
-
     axiom_node_t *om_ele_node;
 
     axiom_soap_fault_sub_code_t *subcode;
@@ -37,87 +33,36 @@
 
     int soap_version;
 
-}
-axiom_soap_fault_code_impl_t;
-
-/******************** Macro **************************************************/
-
-#define AXIS2_INTF_TO_IMPL(code) ((axiom_soap_fault_code_impl_t*)code)
-
-/******************** function prototypes ************************************/
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_code_free(axiom_soap_fault_code_t *fault_code,
-        const axis2_env_t *env);
-
-axiom_soap_fault_sub_code_t* AXIS2_CALL
-axiom_soap_fault_code_get_sub_code(axiom_soap_fault_code_t *fault_code,
-        const axis2_env_t *env);
-
-axiom_soap_fault_value_t* AXIS2_CALL
-axiom_soap_fault_code_get_value(axiom_soap_fault_code_t *fault_code,
-        const axis2_env_t *env);
-
-
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_code_get_base_node(axiom_soap_fault_code_t *fault_code,
-        const axis2_env_t *env);
-
-/********************* function implementation ********************************/
+};
 
 AXIS2_EXTERN axiom_soap_fault_code_t * AXIS2_CALL
 axiom_soap_fault_code_create(const axis2_env_t *env)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
+    axiom_soap_fault_code_t *fault_code = NULL;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_code_impl = (axiom_soap_fault_code_impl_t*) AXIS2_MALLOC(
+    fault_code = (axiom_soap_fault_code_t*) AXIS2_MALLOC(
                 env->allocator,
-                sizeof(axiom_soap_fault_code_impl_t));
-    if (!fault_code_impl)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;
-    }
-
-    fault_code_impl->fault_code.ops = NULL;
-    fault_code_impl->om_ele_node = NULL;
-    fault_code_impl->subcode = NULL;
-    fault_code_impl->value = NULL;
-    fault_code_impl->builder = NULL;
-    fault_code_impl->soap_version = AXIOM_SOAP_VERSION_NOT_SET;
-    fault_code_impl->fault_code.ops =
-        (axiom_soap_fault_code_ops_t*)AXIS2_MALLOC(env->allocator,
-                sizeof(axiom_soap_fault_code_ops_t));
-
-    if (!(fault_code_impl->fault_code.ops))
+                sizeof(axiom_soap_fault_code_t));
+    if (!fault_code)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        AXIS2_FREE(env->allocator, fault_code_impl);
         return NULL;
     }
 
-    fault_code_impl->fault_code.ops->free_fn =
-        axiom_soap_fault_code_free;
+    fault_code->om_ele_node = NULL;
+    fault_code->subcode = NULL;
+    fault_code->value = NULL;
+    fault_code->builder = NULL;
+    fault_code->soap_version = AXIOM_SOAP_VERSION_NOT_SET;
 
-    fault_code_impl->fault_code.ops->get_sub_code =
-        axiom_soap_fault_code_get_sub_code;
-
-    fault_code_impl->fault_code.ops->get_value =
-        axiom_soap_fault_code_get_value;
-
-    fault_code_impl->fault_code.ops->get_base_node =
-        axiom_soap_fault_code_get_base_node;
-
-    return  &(fault_code_impl->fault_code);
+    return  fault_code;
 }
 
 AXIS2_EXTERN axiom_soap_fault_code_t * AXIS2_CALL
 axiom_soap_fault_code_create_with_parent(const axis2_env_t *env,
         axiom_soap_fault_t *fault)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
     axiom_soap_fault_code_t *fault_code = NULL;
-
     axiom_element_t *this_ele = NULL;
     axiom_node_t *this_node = NULL;
 
@@ -133,8 +78,6 @@
     if (!fault_code)
         return NULL;
 
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-
     parent_node = AXIOM_SOAP_FAULT_GET_BASE_NODE(fault, env);
     if (!parent_node)
     {
@@ -149,9 +92,9 @@
         AXIOM_SOAP_FAULT_CODE_FREE(fault_code, env);
         return NULL;
     }
-    fault_code_impl->soap_version =
+    fault_code->soap_version =
         axiom_soap_fault_get_soap_version(fault, env);
-    if (fault_code_impl->soap_version == AXIOM_SOAP12)
+    if (fault_code->soap_version == AXIOM_SOAP12)
     {
         parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
     }
@@ -166,11 +109,11 @@
         return NULL;
     }
 
-    fault_code_impl->om_ele_node = this_node;
+    fault_code->om_ele_node = this_node;
 
     axiom_soap_fault_set_code(fault, env, fault_code);
 
-    return  &(fault_code_impl->fault_code);
+    return  fault_code;
 }
 
 AXIS2_EXTERN axiom_soap_fault_code_t * AXIS2_CALL
@@ -197,50 +140,40 @@
     return fault_code;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_code_free(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
 
-    if (fault_code_impl->subcode)
-    {
-        AXIOM_SOAP_FAULT_SUB_CODE_FREE(fault_code_impl->subcode, env);
-        fault_code_impl->subcode = NULL;
-    }
-    if (fault_code_impl->value)
+    if (fault_code->subcode)
     {
-        AXIOM_SOAP_FAULT_VALUE_FREE(fault_code_impl->value, env);
-        fault_code_impl->value = NULL;
+        AXIOM_SOAP_FAULT_SUB_CODE_FREE(fault_code->subcode, env);
+        fault_code->subcode = NULL;
     }
-    if (fault_code->ops)
+    if (fault_code->value)
     {
-        AXIS2_FREE(env->allocator, fault_code->ops);
-        fault_code->ops = NULL;
+        AXIOM_SOAP_FAULT_VALUE_FREE(fault_code->value, env);
+        fault_code->value = NULL;
     }
 
-    AXIS2_FREE(env->allocator, fault_code_impl);
-    fault_code_impl = NULL;
+    AXIS2_FREE(env->allocator, fault_code);
+    fault_code = NULL;
     return AXIS2_SUCCESS;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_code_set_value(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env,
         axiom_soap_fault_value_t *fault_val)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
     AXIS2_PARAM_CHECK(env->error, fault_val, AXIS2_FAILURE);
 
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-    if (!(fault_code_impl->value))
+    if (!(fault_code->value))
     {
-        fault_code_impl->value = fault_val;
+        fault_code->value = fault_val;
         return AXIS2_SUCCESS;
     }
     else
@@ -251,21 +184,17 @@
     return AXIS2_FAILURE;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_code_set_sub_code(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env,
         axiom_soap_fault_sub_code_t *fault_subcode)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, fault_subcode, AXIS2_FAILURE);
 
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-
-    if (!(fault_code_impl->subcode))
+    if (!(fault_code->subcode))
     {
-        fault_code_impl->subcode = fault_subcode;
+        fault_code->subcode = fault_subcode;
         return AXIS2_SUCCESS;
     }
     else
@@ -276,125 +205,110 @@
     return AXIS2_FAILURE;
 }
 
-axiom_soap_fault_sub_code_t* AXIS2_CALL
+AXIS2_EXTERN axiom_soap_fault_sub_code_t* AXIS2_CALL
 axiom_soap_fault_code_get_sub_code(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
     int status = AXIS2_SUCCESS;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
 
-    if (fault_code_impl->subcode)
+    if (fault_code->subcode)
     {
-        return fault_code_impl->subcode;
+        return fault_code->subcode;
     }
-    else if (fault_code_impl->builder)
+    else if (fault_code->builder)
     {
-        while (!(fault_code_impl->subcode) &&
-                !(AXIOM_NODE_IS_COMPLETE(fault_code_impl->om_ele_node, env)))
+        while (!(fault_code->subcode) &&
+                !(AXIOM_NODE_IS_COMPLETE(fault_code->om_ele_node, env)))
         {
-            status = AXIOM_SOAP_BUILDER_NEXT(fault_code_impl->builder, env);
+            status = AXIOM_SOAP_BUILDER_NEXT(fault_code->builder, env);
             if (status == AXIS2_FAILURE)
             {
                 break;
             }
         }
     }
-    return fault_code_impl->subcode;
+    return fault_code->subcode;
 }
 
-axiom_soap_fault_value_t* AXIS2_CALL
+AXIS2_EXTERN axiom_soap_fault_value_t* AXIS2_CALL
 axiom_soap_fault_code_get_value(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
-
     int status = AXIS2_SUCCESS;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-
-    if (fault_code_impl->value)
+    if (fault_code->value)
     {
-        return fault_code_impl->value;
+        return fault_code->value;
     }
-    else if (fault_code_impl->builder)
+    else if (fault_code->builder)
     {
-        while (!(fault_code_impl->value) &&
-                !(AXIOM_NODE_IS_COMPLETE(fault_code_impl->om_ele_node, env)))
+        while (!(fault_code->value) &&
+                !(AXIOM_NODE_IS_COMPLETE(fault_code->om_ele_node, env)))
         {
-            status = AXIOM_SOAP_BUILDER_NEXT(fault_code_impl->builder, env);
+            status = AXIOM_SOAP_BUILDER_NEXT(fault_code->builder, env);
             if (status == AXIS2_FAILURE)
             {
                 break;
             }
         }
     }
-    return fault_code_impl->value;
+    return fault_code->value;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_code_set_base_node(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env,
         axiom_node_t *node)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
 
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-
     if (AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    fault_code_impl->om_ele_node = node;
+    fault_code->om_ele_node = node;
     return AXIS2_SUCCESS;
 
 }
 
-axiom_node_t* AXIS2_CALL
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 axiom_soap_fault_code_get_base_node(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(fault_code)->om_ele_node;
+    return fault_code->om_ele_node;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_code_set_builder(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env,
         axiom_soap_builder_t *soap_builder)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, soap_builder, AXIS2_FAILURE);
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-    fault_code_impl->builder = soap_builder;
+    fault_code->builder = soap_builder;
     return AXIS2_SUCCESS;
 }
 
-int AXIS2_CALL
+AXIS2_EXTERN int AXIS2_CALL
 axiom_soap_fault_code_get_soap_version(axiom_soap_fault_code_t  *fault_code,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-    return fault_code_impl->soap_version;
+    return fault_code->soap_version;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_code_set_soap_version(axiom_soap_fault_code_t *fault_code,
         const axis2_env_t *env,
         int soap_version)
 {
-    axiom_soap_fault_code_impl_t *fault_code_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_code_impl = AXIS2_INTF_TO_IMPL(fault_code);
-    fault_code_impl->soap_version = soap_version;
+    fault_code->soap_version = soap_version;
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c?view=diff&rev=496572&r1=496571&r2=496572
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_detail.c Mon Jan 15 18:09:50 2007
@@ -20,90 +20,30 @@
 #include <axiom_node.h>
 #include "_axiom_soap_fault_detail.h"
 
-/******************** impl struct ********************************************/
-
-typedef struct axiom_soap_fault_detail_impl_t
+struct axiom_soap_fault_detail
 {
-    axiom_soap_fault_detail_t fault_detail;
-
     axiom_node_t *om_ele_node;
-
-}
-axiom_soap_fault_detail_impl_t;
-
-/***************** Macro *****************************************************/
-
-#define AXIS2_INTF_TO_IMPL(detail) ((axiom_soap_fault_detail_impl_t*)detail)
-
-/****************** function prototypes ***************************************/
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_detail_free(axiom_soap_fault_detail_t *fault_detail,
-        const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_detail_add_detail_entry
-(axiom_soap_fault_detail_t *fault_detail,
-        const axis2_env_t *env,
-        axiom_node_t *ele_node);
-
-axiom_children_iterator_t* AXIS2_CALL
-axiom_soap_fault_detail_get_all_detail_entries
-(axiom_soap_fault_detail_t *fault_detail,
-        const axis2_env_t *env);
-
-
-
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_detail_get_base_node
-(axiom_soap_fault_detail_t *fault_detail,
-        const axis2_env_t *env);
-
-/******************** function implementations ********************************/
+};
 
 AXIS2_EXTERN axiom_soap_fault_detail_t * AXIS2_CALL
 axiom_soap_fault_detail_create(const axis2_env_t *env)
 {
-    axiom_soap_fault_detail_impl_t *fault_detail_impl = NULL;
+    axiom_soap_fault_detail_t *fault_detail = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    fault_detail_impl = (axiom_soap_fault_detail_impl_t*)AXIS2_MALLOC(
-                env->allocator,
-                sizeof(axiom_soap_fault_detail_impl_t));
-    if (!fault_detail_impl)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;
-    }
-
-    fault_detail_impl->fault_detail.ops = NULL;
-    fault_detail_impl->om_ele_node = NULL;
-
-    fault_detail_impl->fault_detail.ops = (axiom_soap_fault_detail_ops_t*)AXIS2_MALLOC(
+    fault_detail = (axiom_soap_fault_detail_t*)AXIS2_MALLOC(
                 env->allocator,
-                sizeof(axiom_soap_fault_detail_ops_t));
-    if (!(fault_detail_impl->fault_detail.ops))
+                sizeof(axiom_soap_fault_detail_t));
+    if (!fault_detail)
     {
-        AXIS2_FREE(env->allocator, fault_detail_impl);
-        fault_detail_impl = NULL;
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
 
-    fault_detail_impl->fault_detail.ops->free_fn =
-        axiom_soap_fault_detail_free;
-
-    fault_detail_impl->fault_detail.ops->add_detail_entry =
-        axiom_soap_fault_detail_add_detail_entry;
-
-    fault_detail_impl->fault_detail.ops->get_all_detail_entries =
-        axiom_soap_fault_detail_get_all_detail_entries;
+    fault_detail->om_ele_node = NULL;
 
-    fault_detail_impl->fault_detail.ops->get_base_node =
-        axiom_soap_fault_detail_get_base_node;
-
-    return &(fault_detail_impl->fault_detail);
+    return fault_detail;
 }
 
 AXIS2_EXTERN axiom_soap_fault_detail_t * AXIS2_CALL
@@ -111,7 +51,6 @@
 (const axis2_env_t *env,
         axiom_soap_fault_t *fault)
 {
-    axiom_soap_fault_detail_impl_t *fault_detail_impl = NULL;
     axiom_soap_fault_detail_t *fault_detail = NULL;
     axiom_element_t *this_ele = NULL;
     axiom_node_t *this_node = NULL;
@@ -127,8 +66,6 @@
     if (!fault_detail)
         return NULL;
 
-    fault_detail_impl = AXIS2_INTF_TO_IMPL(fault_detail);
-
     parent_node = AXIOM_SOAP_FAULT_GET_BASE_NODE(fault, env);
     if (!parent_node)
         return NULL;
@@ -152,36 +89,29 @@
         AXIOM_SOAP_FAULT_DETAIL_FREE(fault_detail, env);
         return NULL;
     }
-    fault_detail_impl->om_ele_node = this_node;
+    fault_detail->om_ele_node = this_node;
     axiom_soap_fault_set_detail(fault, env, fault_detail);
-    return  &(fault_detail_impl->fault_detail);
+    return  fault_detail;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_detail_free(axiom_soap_fault_detail_t *fault_detail,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    if (fault_detail->ops)
-    {
-        AXIS2_FREE(env->allocator, fault_detail->ops);
-        fault_detail->ops = NULL;
-    }
-    AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(fault_detail));
+    AXIS2_FREE(env->allocator, fault_detail);
     fault_detail = NULL;
     return AXIS2_SUCCESS;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_detail_add_detail_entry
 (axiom_soap_fault_detail_t *fault_detail,
         const axis2_env_t *env,
         axiom_node_t *node)
 {
-    axiom_soap_fault_detail_impl_t *fault_detail_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
-    fault_detail_impl = AXIS2_INTF_TO_IMPL(fault_detail);
 
     if (AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
@@ -190,55 +120,51 @@
         return AXIS2_FAILURE;
     }
 
-    AXIOM_NODE_ADD_CHILD(fault_detail_impl->om_ele_node, env, node);
+    AXIOM_NODE_ADD_CHILD(fault_detail->om_ele_node, env, node);
     return AXIS2_SUCCESS;
 }
 
-axiom_children_iterator_t* AXIS2_CALL
+AXIS2_EXTERN axiom_children_iterator_t* AXIS2_CALL
 axiom_soap_fault_detail_get_all_detail_entries
 (axiom_soap_fault_detail_t *fault_detail,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_detail_impl_t *fault_detail_impl = NULL;
     axiom_element_t *om_ele = NULL;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_detail_impl = AXIS2_INTF_TO_IMPL(fault_detail);
-    if (fault_detail_impl->om_ele_node)
+    if (fault_detail->om_ele_node)
     {
         om_ele = (axiom_element_t *)
-                AXIOM_NODE_GET_DATA_ELEMENT(fault_detail_impl->om_ele_node, env);
+                AXIOM_NODE_GET_DATA_ELEMENT(fault_detail->om_ele_node, env);
         return AXIOM_ELEMENT_GET_CHILDREN(om_ele,  env,
-                fault_detail_impl->om_ele_node);
+                fault_detail->om_ele_node);
     }
     return NULL;
 }
 
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_detail_set_base_node
 (axiom_soap_fault_detail_t *fault_detail,
         const axis2_env_t *env,
         axiom_node_t *node)
 {
-    axiom_soap_fault_detail_impl_t *fault_detail_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
-    fault_detail_impl = AXIS2_INTF_TO_IMPL(fault_detail);
 
     if (AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    fault_detail_impl->om_ele_node = node;
+    fault_detail->om_ele_node = node;
     return AXIS2_SUCCESS;
 }
 
-axiom_node_t* AXIS2_CALL
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 axiom_soap_fault_detail_get_base_node
 (axiom_soap_fault_detail_t *fault_detail,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(fault_detail)->om_ele_node;
+    return fault_detail->om_ele_node;
 }

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c?view=diff&rev=496572&r1=496571&r2=496572
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_node.c Mon Jan 15 18:09:50 2007
@@ -20,97 +20,34 @@
 #include <axiom_element.h>
 #include "_axiom_soap_fault.h"
 
-/********************* impl struct *******************************************/
-
-typedef struct axiom_soap_fault_node_impl_t
+struct axiom_soap_fault_node
 {
-    axiom_soap_fault_node_t fault_node;
-
     axiom_node_t *om_ele_node;
-
-}
-axiom_soap_fault_node_impl_t;
-
-/******************* Macro ***************************************************/
-
-#define AXIS2_INTF_TO_IMPL(node) ((axiom_soap_fault_node_impl_t*)node)
-
-/****************** function prototypes **************************************/
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_node_free(axiom_soap_fault_node_t *fault_node,
-        const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_node_set_value
-(axiom_soap_fault_node_t *fault_node,
-        const axis2_env_t *env,
-        axis2_char_t *fault_val);
-
-axis2_char_t* AXIS2_CALL
-axiom_soap_fault_node_get_value
-(axiom_soap_fault_node_t *fault_node,
-        const axis2_env_t *env);
-
-
-
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_node_get_base_node
-(axiom_soap_fault_node_t *fault_node,
-        const axis2_env_t *env);
-
-
-/*********************** function implementations ****************************/
+};
 
 AXIS2_EXTERN axiom_soap_fault_node_t * AXIS2_CALL
 axiom_soap_fault_node_create(const axis2_env_t *env)
 {
-    axiom_soap_fault_node_impl_t *fault_node_impl = NULL;
+    axiom_soap_fault_node_t *fault_node = NULL;
 
-    fault_node_impl = (axiom_soap_fault_node_impl_t*)AXIS2_MALLOC(
+    fault_node = (axiom_soap_fault_node_t*)AXIS2_MALLOC(
                 env->allocator,
-                sizeof(axiom_soap_fault_node_impl_t));
-    if (!fault_node_impl)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;
-    }
-    fault_node_impl->fault_node.ops = NULL;
-    fault_node_impl->om_ele_node = NULL;
-
-    fault_node_impl->fault_node.ops = (axiom_soap_fault_node_ops_t*)AXIS2_MALLOC(
-                env->allocator, sizeof(axiom_soap_fault_node_ops_t));
-
-    if (!(fault_node_impl->fault_node.ops))
+                sizeof(axiom_soap_fault_node_t));
+    if (!fault_node)
     {
-        AXIS2_FREE(env->allocator, fault_node_impl);
-        fault_node_impl = NULL;
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
+    fault_node->om_ele_node = NULL;
 
-    fault_node_impl->fault_node.ops->get_base_node =
-        axiom_soap_fault_node_get_base_node;
-
-    fault_node_impl->fault_node.ops->set_value =
-        axiom_soap_fault_node_set_value;
-
-    fault_node_impl->fault_node.ops->get_value =
-        axiom_soap_fault_node_get_value;
-
-    fault_node_impl->fault_node.ops->free_fn =
-        axiom_soap_fault_node_free;
-
-    return &(fault_node_impl->fault_node);
+    return fault_node;
 }
 
 AXIS2_EXTERN axiom_soap_fault_node_t * AXIS2_CALL
 axiom_soap_fault_node_create_with_parent(const axis2_env_t *env,
         axiom_soap_fault_t *fault)
 {
-    axiom_soap_fault_node_impl_t *fault_node_impl = NULL;
     axiom_soap_fault_node_t *fault_node = NULL;
-
     axiom_element_t *this_ele = NULL;
     axiom_node_t *this_node = NULL;
 
@@ -126,8 +63,6 @@
     if (!fault_node)
         return NULL;
 
-    fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node);
-
     parent_node = AXIOM_SOAP_FAULT_GET_BASE_NODE(fault, env);
     if (!parent_node)
     {
@@ -156,90 +91,75 @@
         return NULL;
     }
 
-    fault_node_impl->om_ele_node = this_node;
+    fault_node->om_ele_node = this_node;
 
     axiom_soap_fault_set_node(fault, env, fault_node);
 
-    return  &(fault_node_impl->fault_node);
+    return  fault_node;
 }
 
 
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_node_free(axiom_soap_fault_node_t *fault_node,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    if (fault_node->ops)
-    {
-        AXIS2_FREE(env->allocator, fault_node->ops);
-        fault_node->ops = NULL;
-    }
-    AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(fault_node));
+    AXIS2_FREE(env->allocator, fault_node);
     return AXIS2_SUCCESS;
 }
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_node_set_value
-(axiom_soap_fault_node_t *fault_node,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_node_set_value(axiom_soap_fault_node_t *fault_node,
         const axis2_env_t *env,
         axis2_char_t *uri)
 {
-    axiom_soap_fault_node_impl_t *fault_node_impl = NULL;
     axiom_element_t *om_ele = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE);
 
-    fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node);
-    if (fault_node_impl->om_ele_node)
+    if (fault_node->om_ele_node)
     {
         om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
-                    fault_node_impl->om_ele_node, env);
+                    fault_node->om_ele_node, env);
 
         if (om_ele)
         {
             return AXIOM_ELEMENT_SET_TEXT(om_ele, env, uri,
-                    fault_node_impl->om_ele_node);
+                    fault_node->om_ele_node);
         }
     }
 
     return AXIS2_FAILURE;
 }
 
-axis2_char_t* AXIS2_CALL
-axiom_soap_fault_node_get_value
-(axiom_soap_fault_node_t *fault_node,
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+axiom_soap_fault_node_get_value(axiom_soap_fault_node_t *fault_node,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_node_impl_t *fault_node_impl = NULL;
     axiom_element_t *om_ele =  NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
-    fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node);
-    if (fault_node_impl->om_ele_node)
+    if (fault_node->om_ele_node)
     {
         om_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT(
-                    fault_node_impl->om_ele_node, env);
+                    fault_node->om_ele_node, env);
         if (om_ele)
         {
             return AXIOM_ELEMENT_GET_TEXT(om_ele,
-                    env, fault_node_impl->om_ele_node);
+                    env, fault_node->om_ele_node);
         }
 
     }
     return NULL;
 }
 
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_node_set_base_node
-(axiom_soap_fault_node_t *fault_node,
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+axiom_soap_fault_node_set_base_node(axiom_soap_fault_node_t *fault_node,
         const axis2_env_t *env,
         axiom_node_t *node)
 {
-    axiom_soap_fault_node_impl_t* fault_node_impl = NULL;
-    fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node);
-
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
     if (AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
@@ -248,18 +168,15 @@
         return AXIS2_FAILURE;
     }
 
-    fault_node_impl->om_ele_node = node;
+    fault_node->om_ele_node = node;
 
     return AXIS2_SUCCESS;
 }
 
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_node_get_base_node
-(axiom_soap_fault_node_t *fault_node,
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
+axiom_soap_fault_node_get_base_node(axiom_soap_fault_node_t *fault_node,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_node_impl_t* fault_node_impl = NULL;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_node_impl = AXIS2_INTF_TO_IMPL(fault_node);
-    return fault_node_impl->om_ele_node;
+    return fault_node->om_ele_node;
 }

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c?view=diff&rev=496572&r1=496571&r2=496572
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_reason.c Mon Jan 15 18:09:50 2007
@@ -22,11 +22,8 @@
 #include <axiom_soap_builder.h>
 #include <axiom_soap_builder.h>
 
-/*************************** impl struct **************************************/
-
-typedef struct axiom_soap_fault_reason_impl_t
+struct axiom_soap_fault_reason
 {
-    axiom_soap_fault_reason_t fault_reason;
     /* corresponding om element node */
     axiom_node_t *om_ele_node;
 
@@ -35,112 +32,37 @@
     axiom_soap_builder_t *soap_builder;
 
     int soap_version;
-
-}
-axiom_soap_fault_reason_impl_t;
-
-/*************************** Macro ********************************************/
-
-#define AXIS2_INTF_TO_IMPL(reason) ((axiom_soap_fault_reason_impl_t*)reason)
-
-/*************************** function prototypes ******************************/
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_reason_free(axiom_soap_fault_reason_t *fault_reason,
-        const axis2_env_t *env);
-
-axiom_soap_fault_text_t* AXIS2_CALL
-axiom_soap_fault_reason_get_soap_fault_text
-(axiom_soap_fault_reason_t *fault_reason,
-        const axis2_env_t *env,
-        axis2_char_t *lang);
-
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_reason_get_base_node
-(axiom_soap_fault_reason_t *fault_reason,
-        const axis2_env_t *env);
-
-axis2_array_list_t* AXIS2_CALL
-axiom_soap_fault_reason_get_all_soap_fault_texts
-(axiom_soap_fault_reason_t *fault_reason,
-        const axis2_env_t *env);
-
-
-axiom_soap_fault_text_t* AXIS2_CALL
-axiom_soap_fault_reason_get_first_soap_fault_text
-(axiom_soap_fault_reason_t *fault_reason,
-        const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_reason_add_soap_fault_text
-(axiom_soap_fault_reason_t *fault_reason,
-        const axis2_env_t *env,
-        axiom_soap_fault_text_t *fault_text);
+};
 
 static axis2_bool_t
 axiom_soap_fault_reason_lang_exists(axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env,
         axis2_char_t *lang);
 
-
-
-
-/************************* function implementations ***************************/
-
 AXIS2_EXTERN axiom_soap_fault_reason_t * AXIS2_CALL
 axiom_soap_fault_reason_create(const axis2_env_t *env)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
+    axiom_soap_fault_reason_t *fault_reason = NULL;
     AXIS2_ENV_CHECK(env, NULL);
-    fault_reason_impl = (axiom_soap_fault_reason_impl_t*) AXIS2_MALLOC(
+    fault_reason = (axiom_soap_fault_reason_t*) AXIS2_MALLOC(
                 env->allocator,
-                sizeof(axiom_soap_fault_reason_impl_t));
-    if (!fault_reason_impl)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;
-    }
-
-    fault_reason_impl->fault_reason.ops = NULL;
-    fault_reason_impl->om_ele_node = NULL;
-    fault_reason_impl->fault_texts = NULL;
-    fault_reason_impl->fault_reason.ops =
-        (axiom_soap_fault_reason_ops_t*)AXIS2_MALLOC(env->allocator,
-                sizeof(axiom_soap_fault_reason_ops_t));
-
-    if (!(fault_reason_impl->fault_reason.ops))
+                sizeof(axiom_soap_fault_reason_t));
+    if (!fault_reason)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        AXIS2_FREE(env->allocator, fault_reason_impl);
         return NULL;
     }
 
-    fault_reason_impl->fault_reason.ops->free_fn =
-        axiom_soap_fault_reason_free;
-
-    fault_reason_impl->fault_reason.ops->get_soap_fault_text =
-        axiom_soap_fault_reason_get_soap_fault_text;
-
-    fault_reason_impl->fault_reason.ops->get_base_node =
-        axiom_soap_fault_reason_get_base_node;
-
-    fault_reason_impl->fault_reason.ops->get_first_soap_fault_text =
-        axiom_soap_fault_reason_get_first_soap_fault_text;
+    fault_reason->om_ele_node = NULL;
+    fault_reason->fault_texts = NULL;
 
-    fault_reason_impl->fault_reason.ops->get_all_soap_fault_texts =
-        axiom_soap_fault_reason_get_all_soap_fault_texts;
-
-    fault_reason_impl->fault_reason.ops->add_soap_fault_text =
-        axiom_soap_fault_reason_add_soap_fault_text;
-
-    return  &(fault_reason_impl->fault_reason);
+    return  fault_reason;
 }
 
 AXIS2_EXTERN axiom_soap_fault_reason_t * AXIS2_CALL
 axiom_soap_fault_reason_create_with_parent(const axis2_env_t *env,
         axiom_soap_fault_t *fault)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     axiom_soap_fault_reason_t *fault_reason = NULL;
     axiom_element_t *this_ele = NULL;
     axiom_node_t *this_node = NULL;
@@ -155,7 +77,6 @@
     if (!fault_reason)
         return NULL;
 
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
     parent_node = AXIOM_SOAP_FAULT_GET_BASE_NODE(fault, env);
     if (!parent_node)
     {
@@ -167,9 +88,9 @@
     {
         return NULL;
     }
-    fault_reason_impl->soap_version =
+    fault_reason->soap_version =
         axiom_soap_fault_get_soap_version(fault, env);
-    if (fault_reason_impl->soap_version == AXIOM_SOAP12)
+    if (fault_reason->soap_version == AXIOM_SOAP12)
     {
         parent_ns = AXIOM_ELEMENT_GET_NAMESPACE(parent_ele, env, parent_node);
     }
@@ -183,32 +104,30 @@
         return NULL;
     }
 
-    fault_reason_impl->om_ele_node = this_node;
+    fault_reason->om_ele_node = this_node;
 
     axiom_soap_fault_set_reason(fault, env, fault_reason);
-    return  &(fault_reason_impl->fault_reason);
+    return  fault_reason;
 }
 
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_reason_free(axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
 
-    if (fault_reason_impl->fault_texts)
+    if (fault_reason->fault_texts)
     {
         int size = 0;
         int i    = 0;
-        size = AXIS2_ARRAY_LIST_SIZE(fault_reason_impl->fault_texts, env);
+        size = AXIS2_ARRAY_LIST_SIZE(fault_reason->fault_texts, env);
 
         for (i = 0  ; i < size; i++)
         {
             axiom_soap_fault_text_t *fault_text = NULL;
             void *value = NULL;
-            value = AXIS2_ARRAY_LIST_GET(fault_reason_impl->fault_texts, env, i);
+            value = AXIS2_ARRAY_LIST_GET(fault_reason->fault_texts, env, i);
             if (value)
             {
                 fault_text = (axiom_soap_fault_text_t *)value;
@@ -216,29 +135,23 @@
                 fault_text = NULL;
             }
         }
-        AXIS2_ARRAY_LIST_FREE(fault_reason_impl->fault_texts, env);
-        fault_reason_impl->fault_texts = NULL;
-    }
-    if (fault_reason->ops)
-    {
-        AXIS2_FREE(env->allocator, fault_reason->ops);
-        fault_reason->ops = NULL;
+        AXIS2_ARRAY_LIST_FREE(fault_reason->fault_texts, env);
+        fault_reason->fault_texts = NULL;
     }
 
-    AXIS2_FREE(env->allocator, fault_reason_impl);
+    AXIS2_FREE(env->allocator, fault_reason);
 
-    fault_reason_impl = NULL;
+    fault_reason = NULL;
 
     return AXIS2_SUCCESS;
 }
 
-axiom_soap_fault_text_t* AXIS2_CALL
+AXIS2_EXTERN axiom_soap_fault_text_t* AXIS2_CALL
 axiom_soap_fault_reason_get_soap_fault_text
 (axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env,
         axis2_char_t *lang)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     int status = AXIS2_SUCCESS;
     int size = 0;
     int i = 0;
@@ -248,34 +161,33 @@
     if (!lang || (AXIS2_STRCMP(lang, "") == 0))
         return NULL;
 
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
     /** Here we have to build the soap fault reason element completly */
-    if (!fault_reason_impl->fault_texts)
+    if (!fault_reason->fault_texts)
     {
 
-        if (fault_reason_impl->soap_builder &&
-                !(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+        if (fault_reason->soap_builder &&
+                !(AXIOM_NODE_IS_COMPLETE(fault_reason->om_ele_node, env)))
         {
-            while (!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+            while (!(AXIOM_NODE_IS_COMPLETE(fault_reason->om_ele_node, env)))
             {
-                status = AXIOM_SOAP_BUILDER_NEXT(fault_reason_impl->soap_builder, env);
+                status = AXIOM_SOAP_BUILDER_NEXT(fault_reason->soap_builder, env);
                 if (status == AXIS2_FAILURE)
                     return NULL;
             }
         }
     }
 
-    if (!fault_reason_impl->fault_texts)
+    if (!fault_reason->fault_texts)
         return NULL;
 
     /** iterate the array list */
-    size = AXIS2_ARRAY_LIST_SIZE(fault_reason_impl->fault_texts, env);
+    size = AXIS2_ARRAY_LIST_SIZE(fault_reason->fault_texts, env);
     for (i = 0; i < size; i++)
     {
         axiom_soap_fault_text_t *fault_text = NULL;
         void *value = NULL;
 
-        value = AXIS2_ARRAY_LIST_GET(fault_reason_impl->fault_texts, env, i);
+        value = AXIS2_ARRAY_LIST_GET(fault_reason->fault_texts, env, i);
         if (value)
         {
             axis2_char_t *fault_lang = NULL;
@@ -290,126 +202,114 @@
     return NULL;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_reason_set_base_node
 (axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env,
         axiom_node_t *node)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
-
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
 
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
-
     if (AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
         AXIS2_ERROR_SET(env->error,
                 AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    fault_reason_impl->om_ele_node = node;
+    fault_reason->om_ele_node = node;
 
     return AXIS2_SUCCESS;
 }
 
-axiom_node_t* AXIS2_CALL
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 axiom_soap_fault_reason_get_base_node
 (axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(fault_reason)->om_ele_node;
+    return fault_reason->om_ele_node;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_reason_set_builder(axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env,
         axiom_soap_builder_t *builder)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     AXIS2_PARAM_CHECK(env->error, builder, AXIS2_FAILURE);
 
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
-    fault_reason_impl->soap_builder = builder;
+    fault_reason->soap_builder = builder;
     return AXIS2_SUCCESS;
 }
 
-axis2_array_list_t* AXIS2_CALL
+AXIS2_EXTERN axis2_array_list_t* AXIS2_CALL
 axiom_soap_fault_reason_get_all_soap_fault_texts
 (axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     int status = AXIS2_SUCCESS;
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
 
-    if (!(fault_reason_impl->fault_texts) && (fault_reason_impl->soap_builder))
+    if (!(fault_reason->fault_texts) && (fault_reason->soap_builder))
     {
-        if (!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+        if (!(AXIOM_NODE_IS_COMPLETE(fault_reason->om_ele_node, env)))
         {
-            while (!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+            while (!(AXIOM_NODE_IS_COMPLETE(fault_reason->om_ele_node, env)))
             {
-                status = AXIOM_SOAP_BUILDER_NEXT(fault_reason_impl->soap_builder, env);
+                status = AXIOM_SOAP_BUILDER_NEXT(fault_reason->soap_builder, env);
                 if (status == AXIS2_FAILURE)
                     return NULL;
             }
         }
     }
-    return fault_reason_impl->fault_texts;
+    return fault_reason->fault_texts;
 }
 
 
-axiom_soap_fault_text_t* AXIS2_CALL
+AXIS2_EXTERN axiom_soap_fault_text_t* AXIS2_CALL
 axiom_soap_fault_reason_get_first_soap_fault_text
 (axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     int status = AXIS2_SUCCESS;
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
 
-    if (!(fault_reason_impl->fault_texts) && (fault_reason_impl->soap_builder))
+    if (!(fault_reason->fault_texts) && (fault_reason->soap_builder))
     {
-        if (!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+        if (!(AXIOM_NODE_IS_COMPLETE(fault_reason->om_ele_node, env)))
         {
-            while (!(AXIOM_NODE_IS_COMPLETE(fault_reason_impl->om_ele_node, env)))
+            while (!(AXIOM_NODE_IS_COMPLETE(fault_reason->om_ele_node, env)))
             {
-                status = AXIOM_SOAP_BUILDER_NEXT(fault_reason_impl->soap_builder, env);
+                status = AXIOM_SOAP_BUILDER_NEXT(fault_reason->soap_builder, env);
                 if (status == AXIS2_FAILURE)
                     return NULL;
             }
         }
     }
-    if (fault_reason_impl->fault_texts)
+    if (fault_reason->fault_texts)
     {
         void *value = NULL;
-        value = AXIS2_ARRAY_LIST_GET(fault_reason_impl->fault_texts, env, 0);
+        value = AXIS2_ARRAY_LIST_GET(fault_reason->fault_texts, env, 0);
         if (value)
             return (axiom_soap_fault_text_t*)value;
     }
     return NULL;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_reason_add_soap_fault_text
 (axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env,
         axiom_soap_fault_text_t *fault_text)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     if (!fault_text)
         return AXIS2_FAILURE;
 
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
-    if (!(fault_reason_impl->fault_texts))
+    if (!(fault_reason->fault_texts))
     {
-        fault_reason_impl->fault_texts = axis2_array_list_create(env, 1);
-        if (!fault_reason_impl->fault_texts)
+        fault_reason->fault_texts = axis2_array_list_create(env, 1);
+        if (!fault_reason->fault_texts)
             return AXIS2_FAILURE;
-        AXIS2_ARRAY_LIST_ADD(fault_reason_impl->fault_texts, env, fault_text);
+        AXIS2_ARRAY_LIST_ADD(fault_reason->fault_texts, env, fault_text);
     }
     else
     {
@@ -423,7 +323,7 @@
                 return AXIS2_FAILURE;
             /** this soap_fault text already exists */
         }
-        AXIS2_ARRAY_LIST_ADD(fault_reason_impl->fault_texts, env, fault_text);
+        AXIS2_ARRAY_LIST_ADD(fault_reason->fault_texts, env, fault_text);
     }
     return AXIS2_SUCCESS;
 }
@@ -433,21 +333,19 @@
         const axis2_env_t *env,
         axis2_char_t *lang)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     int size = 0;
     int i    = 0;
 
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
 
-    if (!lang || (AXIS2_STRCMP(lang, "") == 0) || !fault_reason_impl->fault_texts)
+    if (!lang || (AXIS2_STRCMP(lang, "") == 0) || !fault_reason->fault_texts)
         return AXIS2_FALSE;
 
-    size = AXIS2_ARRAY_LIST_SIZE(fault_reason_impl->fault_texts, env);
+    size = AXIS2_ARRAY_LIST_SIZE(fault_reason->fault_texts, env);
     for (i = 0; i < size; i++)
     {
         axiom_soap_fault_text_t *fault_text = NULL;
         void *value = NULL;
-        value = AXIS2_ARRAY_LIST_GET(fault_reason_impl->fault_texts, env, i);
+        value = AXIS2_ARRAY_LIST_GET(fault_reason->fault_texts, env, i);
         if (value)
         {
             axis2_char_t *text_lang = NULL;
@@ -463,25 +361,21 @@
     return AXIS2_FALSE;
 }
 /** internal function */
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_reason_set_soap_version(axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env,
         int soap_version)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
-    fault_reason_impl->soap_version = soap_version;
+    fault_reason->soap_version = soap_version;
     return AXIS2_SUCCESS;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_reason_get_soap_version(axiom_soap_fault_reason_t *fault_reason,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_reason_impl_t *fault_reason_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    fault_reason_impl = AXIS2_INTF_TO_IMPL(fault_reason);
-    return fault_reason_impl->soap_version;
+    return fault_reason->soap_version;
 }
 

Modified: webservices/axis2/trunk/c/axiom/src/soap/soap_fault_role.c
URL: http://svn.apache.org/viewvc/webservices/axis2/trunk/c/axiom/src/soap/soap_fault_role.c?view=diff&rev=496572&r1=496571&r2=496572
==============================================================================
--- webservices/axis2/trunk/c/axiom/src/soap/soap_fault_role.c (original)
+++ webservices/axis2/trunk/c/axiom/src/soap/soap_fault_role.c Mon Jan 15 18:09:50 2007
@@ -20,96 +20,36 @@
 #include <axiom_soap_builder.h>
 #include <axiom_element.h>
 
-/***************************** impl struct **********************************/
-
-typedef struct axiom_soap_fault_role_impl_t
+struct axiom_soap_fault_role
 {
-    axiom_soap_fault_role_t fault_role;
-
     axiom_node_t *om_ele_node;
-
-}
-axiom_soap_fault_role_impl_t;
-
-/**************************** Macro *******************************************/
-
-#define AXIS2_INTF_TO_IMPL(role) ((axiom_soap_fault_role_impl_t*)role)
-
-/**************************** function prototypes *****************************/
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_role_free(axiom_soap_fault_role_t *fault_role,
-        const axis2_env_t *env);
-
-axis2_status_t AXIS2_CALL
-axiom_soap_fault_role_set_role_value
-(axiom_soap_fault_role_t *fault_role,
-        const axis2_env_t *env,
-        axis2_char_t* uri);
-
-axis2_char_t* AXIS2_CALL
-axiom_soap_fault_role_get_role_value
-(axiom_soap_fault_role_t *fault_role,
-        const axis2_env_t *env);
-
-axiom_node_t* AXIS2_CALL
-axiom_soap_fault_role_get_base_node
-(axiom_soap_fault_role_t *fault_role,
-        const axis2_env_t *env);
-
-/*********************** end function prototypes ******************************/
-
+};
 
 AXIS2_EXTERN axiom_soap_fault_role_t * AXIS2_CALL
 axiom_soap_fault_role_create(const axis2_env_t *env)
 {
-    axiom_soap_fault_role_impl_t *fault_role_impl = NULL;
+    axiom_soap_fault_role_t *fault_role = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    fault_role_impl = (axiom_soap_fault_role_impl_t*) AXIS2_MALLOC(
+    fault_role = (axiom_soap_fault_role_t*) AXIS2_MALLOC(
                 env->allocator,
-                sizeof(axiom_soap_fault_role_impl_t));
-    if (!fault_role_impl)
-    {
-        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        return NULL;
-    }
-
-    fault_role_impl->fault_role.ops = NULL;
-    fault_role_impl->om_ele_node = NULL;
-
-    fault_role_impl->fault_role.ops =
-        (axiom_soap_fault_role_ops_t*)AXIS2_MALLOC(env->allocator,
-                sizeof(axiom_soap_fault_role_ops_t));
-
-    if (!(fault_role_impl->fault_role.ops))
+                sizeof(axiom_soap_fault_role_t));
+    if (!fault_role)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
-        AXIS2_FREE(env->allocator, fault_role_impl);
         return NULL;
     }
 
-    fault_role_impl->fault_role.ops->free_fn =
-        axiom_soap_fault_role_free;
-
-    fault_role_impl->fault_role.ops->get_role_value =
-        axiom_soap_fault_role_get_role_value;
-
-    fault_role_impl->fault_role.ops->set_role_value =
-        axiom_soap_fault_role_set_role_value;
+    fault_role->om_ele_node = NULL;
 
-    fault_role_impl->fault_role.ops->get_base_node =
-        axiom_soap_fault_role_get_base_node;
-
-    return  &(fault_role_impl->fault_role);
+    return  fault_role;
 }
 
 AXIS2_EXTERN axiom_soap_fault_role_t * AXIS2_CALL
 axiom_soap_fault_role_create_with_parent(const axis2_env_t *env,
         axiom_soap_fault_t *fault)
 {
-    axiom_soap_fault_role_impl_t *fault_role_impl = NULL;
     axiom_soap_fault_role_t *fault_role = NULL;
     int soap_version = -1;
 
@@ -128,8 +68,6 @@
     if (!fault_role)
         return NULL;
 
-    fault_role_impl = AXIS2_INTF_TO_IMPL(fault_role);
-
     parent_node = AXIOM_SOAP_FAULT_GET_BASE_NODE(fault, env);
     if (!parent_node)
     {
@@ -158,104 +96,93 @@
         return NULL;
     }
 
-    fault_role_impl->om_ele_node = this_node;
+    fault_role->om_ele_node = this_node;
 
     axiom_soap_fault_set_role(fault, env, fault_role);
 
-    return  &(fault_role_impl->fault_role);
+    return fault_role;
 }
 
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_role_free(axiom_soap_fault_role_t *fault_role,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    if (fault_role->ops)
-    {
-        AXIS2_FREE(env->allocator, fault_role->ops);
-        fault_role->ops = NULL;
-    }
-    AXIS2_FREE(env->allocator, AXIS2_INTF_TO_IMPL(fault_role));
+    AXIS2_FREE(env->allocator, fault_role);
     return AXIS2_SUCCESS;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_role_set_role_value
 (axiom_soap_fault_role_t *fault_role,
         const axis2_env_t *env,
         axis2_char_t* uri)
 {
-    axiom_soap_fault_role_impl_t *fault_role_impl = NULL;
     axiom_element_t *role_ele = NULL;
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, uri, AXIS2_FAILURE);
-    fault_role_impl = AXIS2_INTF_TO_IMPL(fault_role);
 
-    if (!fault_role_impl->om_ele_node)
+    if (!fault_role->om_ele_node)
         return AXIS2_FAILURE;
 
     role_ele = (axiom_element_t*)AXIOM_NODE_GET_DATA_ELEMENT
-            (fault_role_impl->om_ele_node, env);
+            (fault_role->om_ele_node, env);
 
     if (role_ele)
     {
         return AXIOM_ELEMENT_SET_TEXT(role_ele,  env, uri,
-                fault_role_impl->om_ele_node);
+                fault_role->om_ele_node);
     }
     return AXIS2_FAILURE;
 }
 
-axis2_char_t* AXIS2_CALL
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
 axiom_soap_fault_role_get_role_value
 (axiom_soap_fault_role_t *fault_role,
         const axis2_env_t *env)
 {
-    axiom_soap_fault_role_impl_t *fault_role_impl = NULL;
     axiom_element_t *role_ele = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
-    fault_role_impl = AXIS2_INTF_TO_IMPL(fault_role);
-    if (!fault_role_impl->om_ele_node)
+    if (!fault_role->om_ele_node)
         return NULL;
 
     role_ele = (axiom_element_t *)AXIOM_NODE_GET_DATA_ELEMENT
-            (fault_role_impl->om_ele_node, env);
+            (fault_role->om_ele_node, env);
 
     if (role_ele)
     {
         return AXIOM_ELEMENT_GET_TEXT(role_ele,  env,
-                fault_role_impl->om_ele_node);
+                fault_role->om_ele_node);
     }
     return NULL;
 }
 
-axis2_status_t AXIS2_CALL
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axiom_soap_fault_role_set_base_node
 (axiom_soap_fault_role_t *fault_role,
         const axis2_env_t *env,
         axiom_node_t *node)
 {
-    axiom_soap_fault_role_impl_t *fault_role_impl = NULL;
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env->error, node, AXIS2_FAILURE);
-    fault_role_impl = AXIS2_INTF_TO_IMPL(fault_role);
 
     if (AXIOM_NODE_GET_NODE_TYPE(node, env) != AXIOM_ELEMENT)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_BASE_TYPE, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
-    fault_role_impl->om_ele_node = node;
+    fault_role->om_ele_node = node;
     return AXIS2_SUCCESS;
 }
 
-axiom_node_t* AXIS2_CALL
+AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 axiom_soap_fault_role_get_base_node
 (axiom_soap_fault_role_t *fault_role,
         const axis2_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
-    return AXIS2_INTF_TO_IMPL(fault_role)->om_ele_node;
+    return fault_role->om_ele_node;
 }



---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org


Mime
View raw message