axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r529985 [2/2] - in /webservices/axis2/scratch/c/neethi: include/ src/ src/secpolicy/builder/
Date Wed, 18 Apr 2007 11:24:19 GMT
Modified: webservices/axis2/scratch/c/neethi/src/policy_operator.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/policy_operator.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/policy_operator.c (original)
+++ webservices/axis2/scratch/c/neethi/src/policy_operator.c Wed Apr 18 04:24:18 2007
@@ -17,81 +17,81 @@
 
 
 
-#include <policy_operator.h>
-#include <policy.h>
-#include <policy_exactlyone.h>
-#include <policy_all.h>
-#include <policy_reference.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_reference.h>
 
 
-struct policy_operator_t
+struct neethi_operator_t
 {
     void *value;
-    policy_operator_type_t type;
+    neethi_operator_type_t type;
 
 };
 
-AXIS2_EXTERN policy_operator_t *AXIS2_CALL 
-policy_operator_create(const axutil_env_t *env)
+AXIS2_EXTERN neethi_operator_t *AXIS2_CALL 
+neethi_operator_create(const axutil_env_t *env)
 {
-    policy_operator_t *policy_operator = NULL;
+    neethi_operator_t *neethi_operator = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    policy_operator =  (policy_operator_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (policy_operator_t));
+    neethi_operator =  (neethi_operator_t *) AXIS2_MALLOC (env->allocator,
+    sizeof (neethi_operator_t));
 
-    if(policy_operator == NULL)
+    if(neethi_operator == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy_operator->value = NULL;
-    policy_operator->type = OPERATOR_TYPE_UNKNOWN;
+    neethi_operator->value = NULL;
+    neethi_operator->type = OPERATOR_TYPE_UNKNOWN;
 
-    return policy_operator;
+    return neethi_operator;
 
 }
 
 AXIS2_EXTERN void AXIS2_CALL 
-policy_operator_free(policy_operator_t *policy_operator,
+neethi_operator_free(neethi_operator_t *neethi_operator,
         const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
-    if(policy_operator)
+    if(neethi_operator)
     {
-        if(policy_operator->value)
+        if(neethi_operator->value)
         {
-            switch(policy_operator->type)
+            switch(neethi_operator->type)
             {
                 case OPERATOR_TYPE_POLICY:
-                    policy_free((policy_t *)policy_operator->value,env);
-                    policy_operator->value = NULL;
+                    neethi_policy_free((neethi_policy_t *)neethi_operator->value,env);
+                    neethi_operator->value = NULL;
                     break;
 
                 case OPERATOR_TYPE_ALL:
-                    policy_all_free((policy_all_t *)policy_operator->value,env);
-                    policy_operator->value = NULL;
+                    neethi_all_free((neethi_all_t *)neethi_operator->value,env);
+                    neethi_operator->value = NULL;
                     break;
 
                 case OPERATOR_TYPE_EXACTLYONE:
-                    policy_exactlyone_free((policy_exactlyone_t *)policy_operator->value,env);
-                    policy_operator->value = NULL;
+                    neethi_exactlyone_free((neethi_exactlyone_t *)neethi_operator->value,env);
+                    neethi_operator->value = NULL;
                     break;
                 
                 case OPERATOR_TYPE_REFERENCE:
-                    policy_reference_free((policy_reference_t *)policy_operator->value,env);
-                    policy_operator->value = NULL;
+                    neethi_reference_free((neethi_reference_t *)neethi_operator->value,env);
+                    neethi_operator->value = NULL;
                     break;
    
                 /*case OPERATOR_TYPE_ASSERTION:
-                    policy_assertion_free((policy_t *)policy_operator->value,env);
-                    policy_operator->value = NULL;
+                    neethi_assertion_free((neethi_policy_t *)neethi_operator->value,env);
+                    neethi_operator->value = NULL;
                     break;
                 */
             }
-            AXIS2_FREE(env->allocator,policy_operator->value);     
+            AXIS2_FREE(env->allocator,neethi_operator->value);     
         }            
     }
     return; 
@@ -100,35 +100,35 @@
 
 /* Implementations */
 
-AXIS2_EXTERN policy_operator_type_t AXIS2_CALL 
-policy_operator_get_type(policy_operator_t *policy_operator,
+AXIS2_EXTERN neethi_operator_type_t AXIS2_CALL 
+neethi_operator_get_type(neethi_operator_t *neethi_operator,
             const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
         
-    return policy_operator->type;
+    return neethi_operator->type;
 }
 
 AXIS2_EXTERN void *AXIS2_CALL
-policy_operator_get_value(
-    policy_operator_t *policy_operator,
+neethi_operator_get_value(
+    neethi_operator_t *neethi_operator,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return policy_operator->value;
+    return neethi_operator->value;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_operator_set_value(policy_operator_t *policy_operator,
+neethi_operator_set_value(neethi_operator_t *neethi_operator,
     const axutil_env_t *env,
     void *value,
-    policy_operator_type_t type)
+    neethi_operator_type_t type)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    policy_operator->type = type;
-    policy_operator->value =(void *)value;
+    neethi_operator->type = type;
+    neethi_operator->value =(void *)value;
 
     return AXIS2_SUCCESS;
 }

Modified: webservices/axis2/scratch/c/neethi/src/reference.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/reference.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/reference.c (original)
+++ webservices/axis2/scratch/c/neethi/src/reference.c Wed Apr 18 04:24:18 2007
@@ -17,43 +17,43 @@
 
 
 
-#include <policy_reference.h>
+#include <neethi_reference.h>
 
-struct policy_reference_t
+struct neethi_reference_t
 {
     axis2_char_t *uri;
 };
 
-AXIS2_EXTERN policy_reference_t *AXIS2_CALL 
-policy_reference_create(const axutil_env_t *env)
+AXIS2_EXTERN neethi_reference_t *AXIS2_CALL 
+neethi_reference_create(const axutil_env_t *env)
 {
-    policy_reference_t *policy_reference = NULL;
+    neethi_reference_t *neethi_reference = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    policy_reference =  (policy_reference_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (policy_reference_t));
+    neethi_reference =  (neethi_reference_t *) AXIS2_MALLOC (env->allocator,
+    sizeof (neethi_reference_t));
 
-    if(policy_reference == NULL)
+    if(neethi_reference == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy_reference->uri = NULL;
+    neethi_reference->uri = NULL;
 
-    return policy_reference;
+    return neethi_reference;
 }
 
 AXIS2_EXTERN void AXIS2_CALL 
-policy_reference_free(policy_reference_t *policy_reference,
+neethi_reference_free(neethi_reference_t *neethi_reference,
         const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    if(policy_reference)
+    if(neethi_reference)
     {        
-        AXIS2_FREE(env->allocator,policy_reference);
-        policy_reference = NULL;
+        AXIS2_FREE(env->allocator,neethi_reference);
+        neethi_reference = NULL;
     }
     return;
 }
@@ -62,24 +62,24 @@
 /* Implementations */
 
 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
-policy_reference_get_uri(
-    policy_reference_t *policy_reference,
+neethi_reference_get_uri(
+    neethi_reference_t *neethi_reference,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return policy_reference->uri;
+    return neethi_reference->uri;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-policy_reference_set_uri(
-        policy_reference_t *policy_reference,
+neethi_reference_set_uri(
+        neethi_reference_t *neethi_reference,
         const axutil_env_t *env,
         axis2_char_t *uri)
 {
 
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
-    policy_reference->uri = uri;
+    neethi_reference->uri = uri;
     return AXIS2_SUCCESS;
 }
 

Modified: webservices/axis2/scratch/c/neethi/src/registry.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/registry.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/registry.c (original)
+++ webservices/axis2/scratch/c/neethi/src/registry.c Wed Apr 18 04:24:18 2007
@@ -17,89 +17,89 @@
 
 
 
-#include <policy_registry.h>
+#include <neethi_registry.h>
 
-struct policy_registry_t
+struct neethi_registry_t
 {
     axutil_hash_t *registry;
 };
 
-AXIS2_EXTERN policy_registry_t *AXIS2_CALL 
-policy_registry_create(const axutil_env_t *env)
+AXIS2_EXTERN neethi_registry_t *AXIS2_CALL 
+neethi_registry_create(const axutil_env_t *env)
 {
-    policy_registry_t *policy_registry = NULL;
+    neethi_registry_t *neethi_registry = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    policy_registry =  (policy_registry_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (policy_registry_t));
+    neethi_registry =  (neethi_registry_t *) AXIS2_MALLOC (env->allocator,
+    sizeof (neethi_registry_t));
 
-    if(policy_registry == NULL)
+    if(neethi_registry == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy_registry->registry = NULL;
+    neethi_registry->registry = NULL;
 
-    policy_registry->registry = axutil_hash_make(env);
-    if (!(policy_registry->registry))
+    neethi_registry->registry = axutil_hash_make(env);
+    if (!(neethi_registry->registry))
     {
-        policy_registry_free(policy_registry, env);
+        neethi_registry_free(neethi_registry, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    return policy_registry;
+    return neethi_registry;
 }
 
 AXIS2_EXTERN void AXIS2_CALL 
-policy_registry_free(policy_registry_t *policy_registry,
+neethi_registry_free(neethi_registry_t *neethi_registry,
         const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
-    if (policy_registry->registry)
+    if (neethi_registry->registry)
     {
         axutil_hash_index_t *hi = NULL;
         void *val = NULL;
-        for (hi = axutil_hash_first(policy_registry->registry, env); hi;
+        for (hi = axutil_hash_first(neethi_registry->registry, env); hi;
                 hi = axutil_hash_next(env, hi))
         {
-            policy_t *policy = NULL;
+            neethi_policy_t *neethi_policy = NULL;
             axutil_hash_this(hi, NULL, NULL, &val);
-            policy = (policy_t *) val;
-            if (policy)
-                 policy_free(policy, env);
+            neethi_policy = (neethi_policy_t *) val;
+            if (neethi_policy)
+                 neethi_policy_free(neethi_policy, env);
             val = NULL;
-            policy = NULL;
+            neethi_policy = NULL;
 
         }
-        axutil_hash_free(policy_registry->registry , env);
+        axutil_hash_free(neethi_registry->registry , env);
     }
-    AXIS2_FREE(env->allocator,policy_registry);
+    AXIS2_FREE(env->allocator,neethi_registry);
 }
 
 
 /* Implementations */
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-policy_registry_register(
-    policy_registry_t *policy_registry,
+neethi_registry_register(
+    neethi_registry_t *neethi_registry,
     const axutil_env_t *env,
     axis2_char_t *key,
-    policy_t *value)
+    neethi_policy_t *value)
 
 {
-    axutil_hash_set(policy_registry->registry, key , AXIS2_HASH_KEY_STRING, value);
+    axutil_hash_set(neethi_registry->registry, key , AXIS2_HASH_KEY_STRING, value);
     return AXIS2_SUCCESS;
 }
 
-AXIS2_EXTERN policy_t *AXIS2_CALL 
-policy_registry_lookup(
-    policy_registry_t *policy_registry,
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL 
+neethi_registry_lookup(
+    neethi_registry_t *neethi_registry,
     const axutil_env_t *env,
     axis2_char_t *key)
 {
-    return (policy_t *)axutil_hash_get(policy_registry->registry,key ,
+    return (neethi_policy_t *)axutil_hash_get(neethi_registry->registry,key ,
         AXIS2_HASH_KEY_STRING);
 
 }

Modified: webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_binding_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_binding_builder.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_binding_builder.c (original)
+++ webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_binding_builder.c Wed
Apr 18 04:24:18 2007
@@ -16,19 +16,19 @@
  */
 
 #include <rp_transport_binding_builder.h>
-#include <policy_operator.h>
+#include <neethi_operator.h>
 #include <policy.h>
-#include <policy_assertion.h>
-#include <policy_exactlyone.h>
-#include <policy_all.h>
-#include <policy_engine.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
 
 /*private functions*/
 
 axis2_status_t AXIS2_CALL
 transport_binding_process_alternatives(
         const axutil_env_t *env,
-        policy_all_t *all,
+        neethi_all_t *all,
         rp_transport_binding_t *transport_binding);
 
 /***********************************/
@@ -46,8 +46,8 @@
     axiom_node_t *child_node = NULL;
     axiom_element *child_element = NULL;
     axutil_array_list_t *alternatives = NULL;
-    policy_operator_t *component = NULL;
-    policy_all_t *all = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
 
     transport_binding = rp_transport_binding_create(env);
     
@@ -58,15 +58,15 @@
         child_element = (axiom_element_t*)axiom_node_get_data_element(child_node, env);
         if(child_element)
         {
-            policy = policy_engine_get_policy(env, child_node, child_element);
+            policy = neethi_engine_get_policy(env, child_node, child_element);
             if(!policy)
             {
                 return NULL;
             }
-            policy = policy_engine_get_normalize(policy, AXIS2_FALSE, env); 
+            policy = neethi_engine_get_normalize(policy, AXIS2_FALSE, env); 
             alternatives = policy_get_alternatives(policy, env);
-            component = (policy_operator_t *)axutil_array_list_get(alternatives, env, 0);
           
-            all = (policy_all_t *)policy_operator_get_value(component ,env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
           
+            all = (neethi_all_t *)neethi_operator_get_value(component ,env);
             transport_binding_process_alternatives(env, all, transport_binding);
 
             return transport_binding;
@@ -79,35 +79,35 @@
 axis2_status_t AXIS2_CALL
 transport_binding_process_alternatives(
         const axutil_env_t *env,
-        policy_all_t *all,
+        neethi_all_t *all,
         rp_transport_binding_t *transport_binding)
 {
 
-    policy_operator_t *operator = NULL;
+    neethi_operator_t *operator = NULL;
     axutil_array_list_t *arraylist = NULL;
-    policy_assertion_t *assertion = NULL;
-    policy_assertion_type_t *type;    
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t *type;    
     void *value = NULL;
     rp_binding_commons_t *commons = NULL;
 
     int i = 0;
 
-    arraylist = policy_all_get_policy_components(all, env);
+    arraylist = neethi_all_get_policy_components(all, env);
     commons = rp_binding_commons_create(env);    
 
     for(i=0; i<axutil_array_list_size(arraylist, env); i++)
     {
-        operator = (policy_operator_t *)axutil_array_list_get(arraylist, env, i);
-        assertion = (policy_assertion_t *)policy_operator_get_value(operator, env);
-        value = policy_assertion_get_value(assertion, env);
-        type = policy_assertion_get_type(assertion, env);
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
 
         if(value)
         {
             if(type == ASSERTION_TYPE_TRANSPORT_TOKEN)
             {
                 rp_property_t *transport_token = NULL;    
-                transport_token = (rp_property_t *)policy_assertion_get_value(assertion,
env);
+                transport_token = (rp_property_t *)neethi_assertion_get_value(assertion,
env);
                 if(transport_token)
                 {
                     rp_transport_binding_set_transport_token(transport_binding, env, transport_token);
@@ -117,7 +117,7 @@
             else if(type == ASSERTION_TYPE_ALGORITHM_SUITE)
             {
                 rp_algorithmsuite_t *algorithmsuite = NULL;
-                algorithmsuite = (rp_algorithmsuite_t *)policy_assertion_get_value(assertion,
env);
+                algorithmsuite = (rp_algorithmsuite_t *)neethi_assertion_get_value(assertion,
env);
                 if(algorithmsuite)
                 {
                     rp_binding_commons_set_algorithmsuite(commons, env, algorithmsuite);
@@ -131,7 +131,7 @@
             else if(type == ASSERTION_TYPE_LAYOUT)
             {
                 rp_layout_t *layout = NULL;
-                layout = (rp_layout_t *)policy_assertion_get_value(assertion, env);
+                layout = (rp_layout_t *)neethi_assertion_get_value(assertion, env);
                 if(layout)
                 {
                     rp_binding_commons_set_layout(commons, env, layout);
@@ -141,7 +141,7 @@
             else if(type == ASSERTION_TYPE_SIGNED_SUPPORTING_TOKENS)
             {
                 rp_supporting_tokens_t *signed_supporting_tokens = NULL;
-                signed_supporting_tokens = (rp_supporting_tokens_t *)policy_assertion_get_value(assertion,
env);
+                signed_supporting_tokens = (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion,
env);
                 if(signed_supporting_tokens)
                 {
                     rp_binding_commons_set_signed_supporting_tokens(commons, env, signed_supporting_tokens);
@@ -151,7 +151,7 @@
             else if(type == ASSERTION_TYPE_SIGNED_ENDORSING_SUPPORTING_TOKENS)
             {
                 rp_supporting_tokens_t *signed_endorsing_supporting_tokens = NULL;
-                signed_endorsing_supporting_tokens = (rp_supporting_tokens_t *)policy_assertion_get_value(assertion,
env);
+                signed_endorsing_supporting_tokens = (rp_supporting_tokens_t *)neethi_assertion_get_value(assertion,
env);
                 if(signed_endorsing_supporting_tokens)
                 {
                     rp_binding_commons_set_signed_endorsing_supporting_tokens(commons, env,
signed_endorsing_supporting_tokens);

Modified: webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_token_builder.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_token_builder.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_token_builder.c (original)
+++ webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_token_builder.c Wed
Apr 18 04:24:18 2007
@@ -16,19 +16,19 @@
  */
 
 #include <rp_transport_token_builder.h>
-#include <policy_operator.h>
+#include <neethi_operator.h>
 #include <policy.h>
-#include <policy_assertion.h>
-#include <policy_exactlyone.h>
-#include <policy_all.h>
-#include <policy_engine.h>
+#include <neethi_assertion.h>
+#include <neethi_exactlyone.h>
+#include <neethi_all.h>
+#include <neethi_engine.h>
 
 /*private functions*/
 
 axis2_status_t AXIS2_CALL
 transport_token_process_alternatives(
         const axutil_env_t *env,
-        policy_all_t *all,
+        neethi_all_t *all,
         rp_property_t *transport_token);
 
 /***********************************/
@@ -46,8 +46,8 @@
     axiom_node_t *child_node = NULL;
     axiom_element *child_element = NULL;
     axutil_array_list_t *alternatives = NULL;
-    policy_operator_t *component = NULL;
-    policy_all_t *all = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_all_t *all = NULL;
 
     transport_token = rp_property_create(env);
     
@@ -58,15 +58,15 @@
         child_element = (axiom_element_t*)axiom_node_get_data_element(child_node, env);
         if(child_element)
         {
-            policy = policy_engine_get_policy(env, child_node, child_element);
+            policy = neethi_engine_get_policy(env, child_node, child_element);
             if(!policy)
             {
                 return NULL;
             }
-            policy = policy_engine_get_normalize(policy, AXIS2_FALSE, env); 
+            policy = neethi_engine_get_normalize(policy, AXIS2_FALSE, env); 
             alternatives = policy_get_alternatives(policy, env);
-            component = (policy_operator_t *)axutil_array_list_get(alternatives, env, 0);
           
-            all = (policy_all_t *)policy_operator_get_value(component ,env);
+            component = (neethi_operator_t *)axutil_array_list_get(alternatives, env, 0);
           
+            all = (neethi_all_t *)neethi_operator_get_value(component ,env);
             transport_token_process_alternatives(env, all, transport_token);
 
             return transport_token;
@@ -79,33 +79,33 @@
 axis2_status_t AXIS2_CALL
 transport_token_process_alternatives(
         const axutil_env_t *env,
-        policy_all_t *all,
+        neethi_all_t *all,
         rp_property_t *transport_token)
 {
 
-    policy_operator_t *operator = NULL;
+    neethi_operator_t *operator = NULL;
     axutil_array_list_t *arraylist = NULL;
-    policy_assertion_t *assertion = NULL;
-    policy_assertion_type_t *type;    
+    neethi_assertion_t *assertion = NULL;
+    neethi_assertion_type_t *type;    
     void *value = NULL;
 
     int i = 0;
 
-    arraylist = policy_all_get_policy_components(all, env);
+    arraylist = neethi_all_get_policy_components(all, env);
 
     for(i=0; i<axutil_array_list_size(arraylist, env); i++)
     {
-        operator = (policy_operator_t *)axutil_array_list_get(arraylist, env, i);
-        assertion = (policy_assertion_t *)policy_operator_get_value(operator, env);
-        value = policy_assertion_get_value(assertion, env);
-        type = policy_assertion_get_type(assertion, env);
+        operator = (neethi_operator_t *)axutil_array_list_get(arraylist, env, i);
+        assertion = (neethi_assertion_t *)neethi_operator_get_value(operator, env);
+        value = neethi_assertion_get_value(assertion, env);
+        type = neethi_assertion_get_type(assertion, env);
 
         if(value)
         {
             if(type == ASSERTION_TYPE_HTTPS_TOKEN)
             {
                 rp_https_token_t *https_token = NULL;    
-                https_token = (rp_https_token_t *)policy_assertion_get_value(assertion, env);
+                https_token = (rp_https_token_t *)neethi_assertion_get_value(assertion, env);
                 if(https_token)
                 {
                     rp_property_set_value(transport_token, env, https_token, RP_TOKEN_HTTPS);

Modified: webservices/axis2/scratch/c/neethi/src/test.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/test.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/test.c (original)
+++ webservices/axis2/scratch/c/neethi/src/test.c Wed Apr 18 04:24:18 2007
@@ -5,7 +5,7 @@
 #include <axutil_error_default.h>
 #include <stdio.h>
 #include <axiom_xml_reader.h>
-#include <policy_engine.h>
+#include <neethi_engine.h>
 
 int main(int argc, char **argv)
 {
@@ -58,18 +58,18 @@
             root_ele = (axiom_element_t*)axiom_node_get_data_element(root, env);
             if(root_ele)
             {
-                policy_t *policy = NULL;
-                policy = policy_engine_get_policy(env,root,root_ele);    
-                if(!policy)
+                neethi_policy_t *neethi_policy = NULL;
+                neethi_policy = neethi_engine_get_policy(env,root,root_ele);    
+                if(!neethi_policy)
                 {
                     printf("Policy Creation fails\n");
                     return 0;
                 }
                 else
                 {                    
-                    policy_t *normalized = NULL;
+                    neethi_policy_t *normalized = NULL;
                     printf("Policy object successfuly created\n");
-                    normalized = policy_engine_normalize(policy,NULL,AXIS2_TRUE,env);
+                    normalized = neethi_engine_normalize(neethi_policy,NULL,AXIS2_TRUE,env);
                 }
             }
         }



---------------------------------------------------------------------
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