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 [1/2] - in /webservices/axis2/scratch/c/neethi: include/ src/ src/secpolicy/builder/
Date Wed, 18 Apr 2007 11:24:19 GMT
Author: samisa
Date: Wed Apr 18 04:24:18 2007
New Revision: 529985

URL: http://svn.apache.org/viewvc?view=rev&rev=529985
Log:
Fixed prefixes

Modified:
    webservices/axis2/scratch/c/neethi/include/neethi_all.h
    webservices/axis2/scratch/c/neethi/include/neethi_assertion.h
    webservices/axis2/scratch/c/neethi/include/neethi_constants.h
    webservices/axis2/scratch/c/neethi/include/neethi_engine.h
    webservices/axis2/scratch/c/neethi/include/neethi_exactlyone.h
    webservices/axis2/scratch/c/neethi/include/neethi_includes.h
    webservices/axis2/scratch/c/neethi/include/neethi_operator.h
    webservices/axis2/scratch/c/neethi/include/neethi_policy.h
    webservices/axis2/scratch/c/neethi/include/neethi_reference.h
    webservices/axis2/scratch/c/neethi/include/neethi_registry.h
    webservices/axis2/scratch/c/neethi/src/all.c
    webservices/axis2/scratch/c/neethi/src/assertion.c
    webservices/axis2/scratch/c/neethi/src/exactlyone.c
    webservices/axis2/scratch/c/neethi/src/policy.c
    webservices/axis2/scratch/c/neethi/src/policy_engine.c
    webservices/axis2/scratch/c/neethi/src/policy_operator.c
    webservices/axis2/scratch/c/neethi/src/reference.c
    webservices/axis2/scratch/c/neethi/src/registry.c
    webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_binding_builder.c
    webservices/axis2/scratch/c/neethi/src/secpolicy/builder/transport_token_builder.c
    webservices/axis2/scratch/c/neethi/src/test.c

Modified: webservices/axis2/scratch/c/neethi/include/neethi_all.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_all.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_all.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_all.h Wed Apr 18 04:24:18 2007
@@ -20,47 +20,47 @@
 
 
 /**
-  * @file policy_all.h
+  * @file neethi_all.h
   * @struct for operator all 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_operator.h>
-#include <policy_includes.h>
+#include <neethi_operator.h>
+#include <neethi_includes.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-        typedef struct policy_all_t policy_all_t; 
+        typedef struct neethi_all_t neethi_all_t; 
 
-        AXIS2_EXTERN policy_all_t *AXIS2_CALL
-        policy_all_create(const axutil_env_t *env);
+        AXIS2_EXTERN neethi_all_t *AXIS2_CALL
+        neethi_all_create(const axutil_env_t *env);
 
         AXIS2_EXTERN void AXIS2_CALL
-        policy_all_free(policy_all_t *policy_all,
+        neethi_all_free(neethi_all_t *neethi_all,
                 const axutil_env_t *env);
                 
         AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-        policy_all_get_policy_components(
-            policy_all_t *policy_all,
+        neethi_all_get_policy_components(
+            neethi_all_t *neethi_all,
             const axutil_env_t *env);
         
         AXIS2_EXTERN axis2_status_t AXIS2_CALL
-        policy_all_add_policy_components(
-            policy_all_t *all,
+        neethi_all_add_policy_components(
+            neethi_all_t *all,
             axutil_array_list_t *arraylist,
             const axutil_env_t *env);
             
         AXIS2_EXTERN axis2_status_t AXIS2_CALL
-        policy_all_add_operator(policy_all_t *policy_all,
+        neethi_all_add_operator(neethi_all_t *neethi_all,
             const axutil_env_t *env,
-            policy_operator_t *op);
+            neethi_operator_t *op);
 
         AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-        policy_all_is_empty(policy_all_t *all,
+        neethi_all_is_empty(neethi_all_t *all,
             const axutil_env_t *env);
 
 

Modified: webservices/axis2/scratch/c/neethi/include/neethi_assertion.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_assertion.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_assertion.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_assertion.h Wed Apr 18 04:24:18 2007
@@ -20,14 +20,14 @@
 
 
 /**
-  * @file policy_assertion.h
+  * @file neethi_assertion.h
   * @common struct for policy assertions. 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_includes.h>
-#include <policy_operator.h>
+#include <neethi_includes.h>
+#include <neethi_operator.h>
 
 #ifdef __cplusplus
 extern "C"
@@ -45,66 +45,66 @@
         ASSERTION_TYPE_SIGNED_ENDORSING_SUPPORTING_TOKENS,
         ASSERTION_TYPE_HTTPS_TOKEN,
         ASSERTION_TYPE_UNKNOWN
-    }policy_assertion_type_t;
+    }neethi_assertion_type_t;
 
-    typedef struct policy_assertion_t policy_assertion_t;
+    typedef struct neethi_assertion_t neethi_assertion_t;
 
-    AXIS2_EXTERN policy_assertion_t *AXIS2_CALL
-    policy_assertion_create(const axutil_env_t *env);
+    AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL
+    neethi_assertion_create(const axutil_env_t *env);
 
-    AXIS2_EXTERN policy_assertion_type_t AXIS2_CALL
-    policy_assertion_get_type(policy_assertion_t *policy_assertion,
+    AXIS2_EXTERN neethi_assertion_type_t AXIS2_CALL
+    neethi_assertion_get_type(neethi_assertion_t *neethi_assertion,
             const axutil_env_t *env);
 
     AXIS2_EXTERN void *AXIS2_CALL
-    policy_assertion_get_value(
-        policy_assertion_t *policy_assertion,
+    neethi_assertion_get_value(
+        neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env);
 
     AXIS2_EXTERN axis2_status_t AXIS2_CALL
-    policy_assertion_set_value(policy_assertion_t *policy_assertion,
+    neethi_assertion_set_value(neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env,
         void *value,
-        policy_assertion_type_t type);
+        neethi_assertion_type_t type);
 
     AXIS2_EXTERN axiom_element_t *AXIS2_CALL
-    policy_assertion_get_element(
-        policy_assertion_t *policy_assertion,
+    neethi_assertion_get_element(
+        neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env);
 
     AXIS2_EXTERN axis2_status_t AXIS2_CALL
-    policy_assertion_set_element(policy_assertion_t *policy_assertion,
+    neethi_assertion_set_element(neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env,
         axiom_element_t *element);
 
     AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-    policy_assertion_get_is_optional(
-        policy_assertion_t *policy_assertion,
+    neethi_assertion_get_is_optional(
+        neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env);
 
     AXIS2_EXTERN axis2_status_t AXIS2_CALL
-    policy_assertion_set_is_optional(policy_assertion_t *policy_assertion,
+    neethi_assertion_set_is_optional(neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env,
         axis2_bool_t is_optional);
         
     AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-    policy_assertion_get_policy_components(
-        policy_assertion_t *policy_assertion,
+    neethi_assertion_get_policy_components(
+        neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env);
 
     AXIS2_EXTERN axis2_status_t AXIS2_CALL
-    policy_assertion_add_policy_components(
-        policy_assertion_t *policy_assertion,
+    neethi_assertion_add_policy_components(
+        neethi_assertion_t *neethi_assertion,
         axutil_array_list_t *arraylist,
         const axutil_env_t *env);
 
     AXIS2_EXTERN axis2_status_t AXIS2_CALL
-    policy_assertion_add_operator(policy_assertion_t *policy_assertion,
+    neethi_assertion_add_operator(neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env,
-        policy_operator_t *op);
+        neethi_operator_t *op);
 
     AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-    policy_assertion_is_empty(policy_assertion_t *policy_assertion,
+    neethi_assertion_is_empty(neethi_assertion_t *neethi_assertion,
             const axutil_env_t *env);
 
 

Modified: webservices/axis2/scratch/c/neethi/include/neethi_constants.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_constants.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_constants.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_constants.h Wed Apr 18 04:24:18 2007
@@ -28,7 +28,7 @@
 #define NEETHI_PREFIX "wsp"
 
 /**
-* @file policy_constants.h
+* @file neethi_constants.h
 * @brief includes all the string constants 
 */
 #ifdef __cplusplus

Modified: webservices/axis2/scratch/c/neethi/include/neethi_engine.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_engine.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_engine.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_engine.h Wed Apr 18 04:24:18 2007
@@ -20,48 +20,48 @@
 
 
 /**
-  * @file policy_engine.h
-  * @contains policy creation logic. 
+  * @file neethi_engine.h
+  * @contains neethi_policy creation logic. 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_includes.h>
-#include <policy_operator.h>
-#include <policy.h>
-#include <policy_all.h>
-#include <policy_exactlyone.h>
-#include <policy_reference.h>
-#include <policy_registry.h>
+#include <neethi_includes.h>
+#include <neethi_operator.h>
+#include <neethi_policy.h>
+#include <neethi_all.h>
+#include <neethi_exactlyone.h>
+#include <neethi_reference.h>
+#include <neethi_registry.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-    AXIS2_EXTERN policy_t *AXIS2_CALL
-    policy_engine_get_policy(
+    AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+    neethi_engine_get_neethi_policy(
             const axutil_env_t *env,
             axiom_node_t *node,
             axiom_element_t *element);
 
-    AXIS2_EXTERN policy_t *AXIS2_CALL
-    policy_engine_get_normalize(
-            policy_t *policy,
+    AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+    neethi_engine_get_normalize(
+            neethi_policy_t *neethi_policy,
             axis2_bool_t deep,
             const axutil_env_t *env);
     
-    AXIS2_EXTERN policy_t *AXIS2_CALL
-    policy_engine_normalize(
-            policy_t *policy,
-            policy_registry_t *registry,
+    AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+    neethi_engine_normalize(
+            neethi_policy_t *neethi_policy,
+            neethi_registry_t *registry,
             axis2_bool_t deep,
             const axutil_env_t *env);
     
-    AXIS2_EXTERN policy_t *AXIS2_CALL
-    policy_engine_merge(
-            policy_t *policy1,
-            policy_t *policy2,
+    AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+    neethi_engine_merge(
+            neethi_policy_t *neethi_policy1,
+            neethi_policy_t *neethi_policy2,
             const axutil_env_t *env);
         
 

Modified: webservices/axis2/scratch/c/neethi/include/neethi_exactlyone.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_exactlyone.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_exactlyone.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_exactlyone.h Wed Apr 18 04:24:18 2007
@@ -20,47 +20,47 @@
 
 
 /**
-  * @file policy_exactlyone.h
+  * @file neethi_exactlyone.h
   * @struct for operator exactlyone 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_operator.h>
-#include <policy_includes.h>
+#include <neethi_operator.h>
+#include <neethi_includes.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-        typedef struct policy_exactlyone_t policy_exactlyone_t; 
+        typedef struct neethi_exactlyone_t neethi_exactlyone_t; 
 
-        AXIS2_EXTERN policy_exactlyone_t *AXIS2_CALL
-        policy_exactlyone_create(const axutil_env_t *env);
+        AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL
+        neethi_exactlyone_create(const axutil_env_t *env);
 
         AXIS2_EXTERN void AXIS2_CALL
-        policy_exactlyone_free(policy_exactlyone_t *policy_exactlyone,
+        neethi_exactlyone_free(neethi_exactlyone_t *neethi_exactlyone,
                 const axutil_env_t *env);
                 
         AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-        policy_exactlyone_get_policy_components(
-            policy_exactlyone_t *policy_exactlyone,
+        neethi_exactlyone_get_policy_components(
+            neethi_exactlyone_t *neethi_exactlyone,
             const axutil_env_t *env);
 
         AXIS2_EXTERN axis2_status_t AXIS2_CALL
-        policy_exactlyone_add_policy_components(
-                policy_exactlyone_t *exactlyone,
+        neethi_exactlyone_add_policy_components(
+                neethi_exactlyone_t *exactlyone,
                 axutil_array_list_t *arraylist,
                 const axutil_env_t *env);
 
         AXIS2_EXTERN axis2_status_t AXIS2_CALL
-        policy_exactlyone_add_operator(policy_exactlyone_t *policy_exactlyone,
+        neethi_exactlyone_add_operator(neethi_exactlyone_t *neethi_exactlyone,
             const axutil_env_t *env,
-            policy_operator_t *op);
+            neethi_operator_t *op);
 
         AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-        policy_exactlyone_is_empty(policy_exactlyone_t *exactlyone,
+        neethi_exactlyone_is_empty(neethi_exactlyone_t *exactlyone,
             const axutil_env_t *env);
 
 

Modified: webservices/axis2/scratch/c/neethi/include/neethi_includes.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_includes.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_includes.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_includes.h Wed Apr 18 04:24:18 2007
@@ -33,11 +33,11 @@
 #include <axiom_soap.h>
 #include <axutil_qname.h>
 #include <axutil_hash.h>
-#include <policy_constants.h>
+#include <neethi_constants.h>
 #include <axutil_hash.h>
 
 /**
-* @file policy_includes.h
+* @file neethi_includes.h
 * @brief includes most useful headers for policy 
 */
 #ifdef __cplusplus

Modified: webservices/axis2/scratch/c/neethi/include/neethi_operator.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_operator.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_operator.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_operator.h Wed Apr 18 04:24:18 2007
@@ -20,13 +20,13 @@
 
 
 /**
-  * @file policy_operator.h
+  * @file neethi_operator.h
   * @common struct for policy operators. 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_includes.h>
+#include <neethi_includes.h>
 
 
 #ifdef __cplusplus
@@ -42,32 +42,32 @@
         OPERATOR_TYPE_REFERENCE,
         OPERATOR_TYPE_ASSERTION,
         OPERATOR_TYPE_UNKNOWN
-    }policy_operator_type_t;
+    }neethi_operator_type_t;
 
-    typedef struct policy_operator_t policy_operator_t;
+    typedef struct neethi_operator_t neethi_operator_t;
 
 
-    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);
 
     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_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_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_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);
 
 
     /** @} */

Modified: webservices/axis2/scratch/c/neethi/include/neethi_policy.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_policy.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_policy.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_policy.h Wed Apr 18 04:24:18 2007
@@ -20,58 +20,58 @@
 
 
 /**
-  * @file policy.h
-  * @struct for operator policy 
+  * @file neethi_policy.h
+  * @struct for operator neethi_policy 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_operator.h>
-#include <policy_includes.h>
-#include <policy_exactlyone.h>
+#include <neethi_operator.h>
+#include <neethi_includes.h>
+#include <neethi_exactlyone.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-        typedef struct policy_t policy_t; 
+        typedef struct neethi_policy_t neethi_policy_t; 
 
-        AXIS2_EXTERN policy_t *AXIS2_CALL
-        policy_create(const axutil_env_t *env);
+        AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+        neethi_policy_create(const axutil_env_t *env);
 
         AXIS2_EXTERN void AXIS2_CALL
-        policy_free(policy_t *policy,
+        neethi_policy_free(neethi_policy_t *neethi_policy,
                 const axutil_env_t *env);
                 
         AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-        policy_get_policy_components(
-            policy_t *policy,
+        neethi_policy_get_neethi_policy_components(
+            neethi_policy_t *neethi_policy,
             const axutil_env_t *env);
 
         AXIS2_EXTERN axis2_status_t AXIS2_CALL
-        policy_add_policy_components(
-            policy_t *policy,
+        neethi_policy_add_neethi_policy_components(
+            neethi_policy_t *neethi_policy,
             axutil_array_list_t *arraylist,
             const axutil_env_t *env);
         
         AXIS2_EXTERN axis2_status_t AXIS2_CALL
-        policy_add_operator(policy_t *policy,
+        neethi_policy_add_operator(neethi_policy_t *neethi_policy,
             const axutil_env_t *env,
-            policy_operator_t *op);
+            neethi_operator_t *op);
 
         AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-        policy_is_empty(policy_t *policy,
+        neethi_policy_is_empty(neethi_policy_t *neethi_policy,
             const axutil_env_t *env);
 
-        AXIS2_EXTERN policy_exactlyone_t *AXIS2_CALL
-        policy_get_exactlyone(
-        policy_t *normalized_policy,
+        AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL
+        neethi_policy_get_exactlyone(
+        neethi_policy_t *normalized_neethi_policy,
             const axutil_env_t *env);
         
         AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-        policy_get_alternatives(
-            policy_t *policy,
+        neethi_policy_get_alternatives(
+            neethi_policy_t *neethi_policy,
             const axutil_env_t *env);
         
 

Modified: webservices/axis2/scratch/c/neethi/include/neethi_reference.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_reference.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_reference.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_reference.h Wed Apr 18 04:24:18 2007
@@ -20,36 +20,36 @@
 
 
 /**
-  * @file policy_reference.h
+  * @file neethi_reference.h
   * @struct for operator reference 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_includes.h>
+#include <neethi_includes.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-        typedef struct policy_reference_t policy_reference_t; 
+        typedef struct neethi_reference_t neethi_reference_t; 
 
-        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);
 
         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_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_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);
                 

Modified: webservices/axis2/scratch/c/neethi/include/neethi_registry.h
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/include/neethi_registry.h?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/include/neethi_registry.h (original)
+++ webservices/axis2/scratch/c/neethi/include/neethi_registry.h Wed Apr 18 04:24:18 2007
@@ -20,39 +20,39 @@
 
 
 /**
-  * @file policy_registry.h
+  * @file neethi_registry.h
   * @struct for operator registry 
   */
 
 #include <axis2_defines.h>
 #include <axutil_env.h>
-#include <policy_includes.h>
-#include <policy.h>
+#include <neethi_includes.h>
+#include <neethi_policy.h>
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-        typedef struct policy_registry_t policy_registry_t; 
+        typedef struct neethi_registry_t neethi_registry_t; 
 
-        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);
 
         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_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);
 
-        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);
 

Modified: webservices/axis2/scratch/c/neethi/src/all.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/all.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/all.c (original)
+++ webservices/axis2/scratch/c/neethi/src/all.c Wed Apr 18 04:24:18 2007
@@ -17,67 +17,67 @@
 
 
 
-#include <policy_all.h>
+#include <neethi_all.h>
 
-struct policy_all_t
+struct neethi_all_t
 {
     axutil_array_list_t *policy_components;
 };
 
-AXIS2_EXTERN policy_all_t *AXIS2_CALL 
-policy_all_create(const axutil_env_t *env)
+AXIS2_EXTERN neethi_all_t *AXIS2_CALL 
+neethi_all_create(const axutil_env_t *env)
 {
-    policy_all_t *policy_all = NULL;
+    neethi_all_t *neethi_all = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    policy_all =  (policy_all_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (policy_all_t));
+    neethi_all =  (neethi_all_t *) AXIS2_MALLOC (env->allocator,
+    sizeof (neethi_all_t));
 
-    if(policy_all == NULL)
+    if(neethi_all == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy_all->policy_components = NULL;
+    neethi_all->policy_components = NULL;
 
-    policy_all->policy_components = axutil_array_list_create(env, 0);
-    if (!(policy_all->policy_components) )
+    neethi_all->policy_components = axutil_array_list_create(env, 0);
+    if (!(neethi_all->policy_components) )
     {
-        policy_all_free(policy_all, env);
+        neethi_all_free(neethi_all, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    return policy_all;
+    return neethi_all;
 }
 
 AXIS2_EXTERN void AXIS2_CALL 
-policy_all_free(policy_all_t *policy_all,
+neethi_all_free(neethi_all_t *neethi_all,
         const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    if(policy_all)
+    if(neethi_all)
     {
-        if(policy_all->policy_components)
+        if(neethi_all->policy_components)
         {
             int i = 0;
-            for (i = 0; i < axutil_array_list_size(policy_all->policy_components,
+            for (i = 0; i < axutil_array_list_size(neethi_all->policy_components,
                 env); i++)
             {
-                policy_operator_t *operator = NULL;
-                operator = (policy_operator_t *)
-                    axutil_array_list_get(policy_all->policy_components,env, i);
+                neethi_operator_t *operator = NULL;
+                operator = (neethi_operator_t *)
+                    axutil_array_list_get(neethi_all->policy_components,env, i);
                 if (operator)
-                    policy_operator_free(operator, env);
+                    neethi_operator_free(operator, env);
 
                 operator = NULL;
             }
-            axutil_array_list_free(policy_all->policy_components , env);
-            policy_all->policy_components = NULL;
+            axutil_array_list_free(neethi_all->policy_components , env);
+            neethi_all->policy_components = NULL;
         }
-        AXIS2_FREE(env->allocator,policy_all);
-        policy_all = NULL;
+        AXIS2_FREE(env->allocator,neethi_all);
+        neethi_all = NULL;
     }
     return;
 }
@@ -86,18 +86,18 @@
 /* Implementations */
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-policy_all_get_policy_components(
-    policy_all_t *policy_all,
+neethi_all_get_policy_components(
+    neethi_all_t *neethi_all,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return policy_all->policy_components;
+    return neethi_all->policy_components;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL 
-policy_all_add_policy_components(
-        policy_all_t *all,
+neethi_all_add_policy_components(
+        neethi_all_t *all,
         axutil_array_list_t *arraylist,
         const axutil_env_t *env)
 {
@@ -120,18 +120,18 @@
 
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_all_add_operator(policy_all_t *policy_all,
+neethi_all_add_operator(neethi_all_t *neethi_all,
             const axutil_env_t *env,
-            policy_operator_t *operator)
+            neethi_operator_t *operator)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    axutil_array_list_add(policy_all->policy_components,env,operator);
+    axutil_array_list_add(neethi_all->policy_components,env,operator);
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-policy_all_is_empty(policy_all_t *all,
+neethi_all_is_empty(neethi_all_t *all,
             const axutil_env_t *env)
 
 {

Modified: webservices/axis2/scratch/c/neethi/src/assertion.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/assertion.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/assertion.c (original)
+++ webservices/axis2/scratch/c/neethi/src/assertion.c Wed Apr 18 04:24:18 2007
@@ -17,66 +17,66 @@
 
 
 
-#include <policy_assertion.h>
+#include <neethi_assertion.h>
 
-struct policy_assertion_t
+struct neethi_assertion_t
 {
     void *value;
-    policy_assertion_type_t type;
+    neethi_assertion_type_t type;
     axutil_array_list_t *policy_components;
     axiom_element_t *element;
     axis2_bool_t is_optional;
 };
 
-AXIS2_EXTERN policy_assertion_t *AXIS2_CALL 
-policy_assertion_create(const axutil_env_t *env)
+AXIS2_EXTERN neethi_assertion_t *AXIS2_CALL 
+neethi_assertion_create(const axutil_env_t *env)
 {
-    policy_assertion_t *policy_assertion = NULL;
+    neethi_assertion_t *neethi_assertion = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    policy_assertion =  (policy_assertion_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (policy_assertion_t));
+    neethi_assertion =  (neethi_assertion_t *) AXIS2_MALLOC (env->allocator,
+    sizeof (neethi_assertion_t));
 
-    if(policy_assertion == NULL)
+    if(neethi_assertion == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy_assertion->policy_components = NULL;
+    neethi_assertion->policy_components = NULL;
 
-    policy_assertion->policy_components = axutil_array_list_create(env, 0);
-    if (!(policy_assertion->policy_components))
+    neethi_assertion->policy_components = axutil_array_list_create(env, 0);
+    if (!(neethi_assertion->policy_components))
     {
 /*      policy_free(policy, env);*/
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy_assertion->value = NULL;
-    policy_assertion->type = ASSERTION_TYPE_UNKNOWN;
-    policy_assertion->element = NULL;
-    policy_assertion->is_optional = AXIS2_FALSE;
+    neethi_assertion->value = NULL;
+    neethi_assertion->type = ASSERTION_TYPE_UNKNOWN;
+    neethi_assertion->element = NULL;
+    neethi_assertion->is_optional = AXIS2_FALSE;
 
-    return policy_assertion;
+    return neethi_assertion;
 }
 
 /*
 This will be implemented later. 
 
 AXIS2_EXTERN void AXIS2_CALL 
-policy_assertion_free(policy_assertion_t *policy_assertion,
+neethi_assertion_free(neethi_assertion_t *neethi_assertion,
         const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     
-    if(policy_assertion)
+    if(neethi_assertion)
     {
-        if(policy_assertion->value)
+        if(neethi_assertion->value)
         {
-            switch(policy_assertion->type)
+            switch(neethi_assertion->type)
             {
             }
-            AXIS2_FREE(env->allocator,policy_assertion->value);     
+            AXIS2_FREE(env->allocator,neethi_assertion->value);     
         }            
     }
     return; 
@@ -85,94 +85,94 @@
 
 /* Implementations */
 
-AXIS2_EXTERN policy_assertion_type_t AXIS2_CALL 
-policy_assertion_get_type(policy_assertion_t *policy_assertion,
+AXIS2_EXTERN neethi_assertion_type_t AXIS2_CALL 
+neethi_assertion_get_type(neethi_assertion_t *neethi_assertion,
             const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
         
-    return policy_assertion->type;
+    return neethi_assertion->type;
 }
 
 AXIS2_EXTERN void *AXIS2_CALL
-policy_assertion_get_value(
-    policy_assertion_t *policy_assertion,
+neethi_assertion_get_value(
+    neethi_assertion_t *neethi_assertion,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return policy_assertion->value;
+    return neethi_assertion->value;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_assertion_set_value(policy_assertion_t *policy_assertion,
+neethi_assertion_set_value(neethi_assertion_t *neethi_assertion,
     const axutil_env_t *env,
     void *value,
-    policy_assertion_type_t type)
+    neethi_assertion_type_t type)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    policy_assertion->type = type;
-    policy_assertion->value =(void *)value;
+    neethi_assertion->type = type;
+    neethi_assertion->value =(void *)value;
 
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axiom_element_t *AXIS2_CALL
-policy_assertion_get_element(
-    policy_assertion_t *policy_assertion,
+neethi_assertion_get_element(
+    neethi_assertion_t *neethi_assertion,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return policy_assertion->element;
+    return neethi_assertion->element;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_assertion_set_element(policy_assertion_t *policy_assertion,
+neethi_assertion_set_element(neethi_assertion_t *neethi_assertion,
     const axutil_env_t *env,
     axiom_element_t *element)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    policy_assertion->element = element;
+    neethi_assertion->element = element;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-policy_assertion_get_is_optional(
-    policy_assertion_t *policy_assertion,
+neethi_assertion_get_is_optional(
+    neethi_assertion_t *neethi_assertion,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return policy_assertion->is_optional;
+    return neethi_assertion->is_optional;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_assertion_set_is_optional(policy_assertion_t *policy_assertion,
+neethi_assertion_set_is_optional(neethi_assertion_t *neethi_assertion,
     const axutil_env_t *env,
     axis2_bool_t is_optional)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    policy_assertion->is_optional = is_optional;
+    neethi_assertion->is_optional = is_optional;
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-policy_assertion_get_policy_components(
-    policy_assertion_t *policy_assertion,
+neethi_assertion_get_policy_components(
+    neethi_assertion_t *neethi_assertion,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
-    return policy_assertion->policy_components;
+    return neethi_assertion->policy_components;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_assertion_add_policy_components(
-        policy_assertion_t *policy_assertion,
+neethi_assertion_add_policy_components(
+        neethi_assertion_t *neethi_assertion,
         axutil_array_list_t *arraylist,
         const axutil_env_t *env)
 {
@@ -180,34 +180,34 @@
     int size = axutil_array_list_size(arraylist,env);
     int i = 0;
 
-    if (axutil_array_list_ensure_capacity(policy_assertion->policy_components , env, size + 1) != AXIS2_SUCCESS)
+    if (axutil_array_list_ensure_capacity(neethi_assertion->policy_components , env, size + 1) != AXIS2_SUCCESS)
             return AXIS2_FAILURE;
 
     for(i=0; i<size; i++)
     {
         void *value = NULL;
         value = axutil_array_list_get(arraylist ,env ,i);
-        axutil_array_list_add(policy_assertion->policy_components,env,value);
+        axutil_array_list_add(neethi_assertion->policy_components,env,value);
     }
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_assertion_add_operator(policy_assertion_t *policy_assertion,
+neethi_assertion_add_operator(neethi_assertion_t *neethi_assertion,
             const axutil_env_t *env,
-            policy_operator_t *operator)
+            neethi_operator_t *operator)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    axutil_array_list_add(policy_assertion->policy_components,env,operator);
+    axutil_array_list_add(neethi_assertion->policy_components,env,operator);
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-policy_assertion_is_empty(policy_assertion_t *policy_assertion,
+neethi_assertion_is_empty(neethi_assertion_t *neethi_assertion,
             const axutil_env_t *env)
 
 {
-    return axutil_array_list_is_empty(policy_assertion->policy_components , env);
+    return axutil_array_list_is_empty(neethi_assertion->policy_components , env);
 }
 

Modified: webservices/axis2/scratch/c/neethi/src/exactlyone.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/exactlyone.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/exactlyone.c (original)
+++ webservices/axis2/scratch/c/neethi/src/exactlyone.c Wed Apr 18 04:24:18 2007
@@ -17,67 +17,67 @@
 
 
 
-#include <policy_exactlyone.h>
+#include <neethi_exactlyone.h>
 
-struct policy_exactlyone_t
+struct neethi_exactlyone_t
 {
     axutil_array_list_t *policy_components;
 };
 
-AXIS2_EXTERN policy_exactlyone_t *AXIS2_CALL 
-policy_exactlyone_create(const axutil_env_t *env)
+AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL 
+neethi_exactlyone_create(const axutil_env_t *env)
 {
-    policy_exactlyone_t *policy_exactlyone = NULL;
+    neethi_exactlyone_t *neethi_exactlyone = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    policy_exactlyone =  (policy_exactlyone_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (policy_exactlyone_t));
+    neethi_exactlyone =  (neethi_exactlyone_t *) AXIS2_MALLOC (env->allocator,
+    sizeof (neethi_exactlyone_t));
 
-    if(policy_exactlyone == NULL)
+    if(neethi_exactlyone == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy_exactlyone->policy_components = NULL;
+    neethi_exactlyone->policy_components = NULL;
 
-    policy_exactlyone->policy_components = axutil_array_list_create(env, 0);
-    if (!(policy_exactlyone->policy_components) )
+    neethi_exactlyone->policy_components = axutil_array_list_create(env, 0);
+    if (!(neethi_exactlyone->policy_components) )
     {
-        policy_exactlyone_free(policy_exactlyone, env);
+        neethi_exactlyone_free(neethi_exactlyone, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    return policy_exactlyone;
+    return neethi_exactlyone;
 }
 
 AXIS2_EXTERN void AXIS2_CALL 
-policy_exactlyone_free(policy_exactlyone_t *policy_exactlyone,
+neethi_exactlyone_free(neethi_exactlyone_t *neethi_exactlyone,
         const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    if(policy_exactlyone)
+    if(neethi_exactlyone)
     {
-        if(policy_exactlyone->policy_components)
+        if(neethi_exactlyone->policy_components)
         {
             int i = 0;
-            for (i = 0; i < axutil_array_list_size(policy_exactlyone->policy_components,
+            for (i = 0; i < axutil_array_list_size(neethi_exactlyone->policy_components,
                 env); i++)
             {
-                policy_operator_t *operator = NULL;
-                operator = (policy_operator_t *)
-                    axutil_array_list_get(policy_exactlyone->policy_components,env, i);
+                neethi_operator_t *operator = NULL;
+                operator = (neethi_operator_t *)
+                    axutil_array_list_get(neethi_exactlyone->policy_components,env, i);
                 if (operator)
-                    policy_operator_free(operator, env);
+                    neethi_operator_free(operator, env);
 
                 operator = NULL;
             }
-            axutil_array_list_free(policy_exactlyone->policy_components , env);
-            policy_exactlyone->policy_components = NULL;
+            axutil_array_list_free(neethi_exactlyone->policy_components , env);
+            neethi_exactlyone->policy_components = NULL;
         }
-        AXIS2_FREE(env->allocator,policy_exactlyone);
-        policy_exactlyone = NULL;
+        AXIS2_FREE(env->allocator,neethi_exactlyone);
+        neethi_exactlyone = NULL;
     }
     return;
 }
@@ -86,19 +86,19 @@
 /* Implementations */
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-policy_exactlyone_get_policy_components(
-    policy_exactlyone_t *policy_exactlyone,
+neethi_exactlyone_get_policy_components(
+    neethi_exactlyone_t *neethi_exactlyone,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    return policy_exactlyone->policy_components;
+    return neethi_exactlyone->policy_components;
 }
 
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_exactlyone_add_policy_components(
-        policy_exactlyone_t *exactlyone,
+neethi_exactlyone_add_policy_components(
+        neethi_exactlyone_t *exactlyone,
         axutil_array_list_t *arraylist,
         const axutil_env_t *env)
 {
@@ -120,18 +120,18 @@
 
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_exactlyone_add_operator(policy_exactlyone_t *policy_exactlyone,
+neethi_exactlyone_add_operator(neethi_exactlyone_t *neethi_exactlyone,
             const axutil_env_t *env,
-            policy_operator_t *operator)
+            neethi_operator_t *operator)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    axutil_array_list_add(policy_exactlyone->policy_components,env,operator);
+    axutil_array_list_add(neethi_exactlyone->policy_components,env,operator);
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-policy_exactlyone_is_empty(policy_exactlyone_t *exactlyone,
+neethi_exactlyone_is_empty(neethi_exactlyone_t *exactlyone,
             const axutil_env_t *env)
 
 {

Modified: webservices/axis2/scratch/c/neethi/src/policy.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/policy.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/policy.c (original)
+++ webservices/axis2/scratch/c/neethi/src/policy.c Wed Apr 18 04:24:18 2007
@@ -17,68 +17,68 @@
 
 
 
-#include <policy.h>
-#include <policy_engine.h>
+#include <neethi_policy.h>
+#include <neethi_engine.h>
 
-struct policy_t
+struct neethi_policy_t
 {
-    axutil_array_list_t *policy_components;
+    axutil_array_list_t *neethi_policy_components;
 };
 
-AXIS2_EXTERN policy_t *AXIS2_CALL 
-policy_create(const axutil_env_t *env)
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL 
+neethi_policy_create(const axutil_env_t *env)
 {
-    policy_t *policy = NULL;
+    neethi_policy_t *neethi_policy = NULL;
 
     AXIS2_ENV_CHECK(env, NULL);
 
-    policy =  (policy_t *) AXIS2_MALLOC (env->allocator,
-    sizeof (policy_t));
+    neethi_policy =  (neethi_policy_t *) AXIS2_MALLOC (env->allocator,
+    sizeof (neethi_policy_t));
 
-    if(policy == NULL)
+    if(neethi_policy == NULL)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    policy->policy_components = NULL;
+    neethi_policy->neethi_policy_components = NULL;
 
-    policy->policy_components = axutil_array_list_create(env, 0);
-    if (!(policy->policy_components) )
+    neethi_policy->neethi_policy_components = axutil_array_list_create(env, 0);
+    if (!(neethi_policy->neethi_policy_components) )
     {
-        policy_free(policy, env);
+        neethi_policy_free(neethi_policy, env);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
-    return policy;
+    return neethi_policy;
 }
 
 AXIS2_EXTERN void AXIS2_CALL 
-policy_free(policy_t *policy,
+neethi_policy_free(neethi_policy_t *neethi_policy,
         const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    if(policy)
+    if(neethi_policy)
     {
-        if(policy->policy_components)
+        if(neethi_policy->neethi_policy_components)
         {
             int i = 0;
-            for (i = 0; i < axutil_array_list_size(policy->policy_components,
+            for (i = 0; i < axutil_array_list_size(neethi_policy->neethi_policy_components,
                 env); i++)
             {
-                policy_operator_t *operator = NULL;
-                operator = (policy_operator_t *)
-                    axutil_array_list_get(policy->policy_components,env, i);
+                neethi_operator_t *operator = NULL;
+                operator = (neethi_operator_t *)
+                    axutil_array_list_get(neethi_policy->neethi_policy_components,env, i);
                 if (operator)
-                    policy_operator_free(operator, env);
+                    neethi_operator_free(operator, env);
 
                 operator = NULL;
             }
-            axutil_array_list_free(policy->policy_components , env);
-            policy->policy_components = NULL;
+            axutil_array_list_free(neethi_policy->neethi_policy_components , env);
+            neethi_policy->neethi_policy_components = NULL;
         }
-        AXIS2_FREE(env->allocator,policy);
-        policy = NULL;
+        AXIS2_FREE(env->allocator,neethi_policy);
+        neethi_policy = NULL;
     }
     return;
 }
@@ -87,18 +87,18 @@
 /* Implementations */
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-policy_get_policy_components(
-    policy_t *policy,
+neethi_policy_get_policy_components(
+    neethi_policy_t *neethi_policy,
     const axutil_env_t *env)
 {
     AXIS2_ENV_CHECK(env, NULL);
 
-    return policy->policy_components;
+    return neethi_policy->neethi_policy_components;
 }
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_add_policy_components(
-        policy_t *policy,
+neethi_policy_add_neethi_policy_components(
+        neethi_policy_t *neethi_policy,
         axutil_array_list_t *arraylist,
         const axutil_env_t *env)
 {
@@ -106,14 +106,14 @@
     int size = axutil_array_list_size(arraylist,env);
     int i = 0;
 
-    if (axutil_array_list_ensure_capacity(policy->policy_components , env, size + 1) != AXIS2_SUCCESS)
+    if (axutil_array_list_ensure_capacity(neethi_policy->neethi_policy_components , env, size + 1) != AXIS2_SUCCESS)
             return AXIS2_FAILURE;
 
     for(i=0; i<size; i++)
     {
         void *value = NULL;
         value = axutil_array_list_get(arraylist ,env ,i);
-        axutil_array_list_add(policy->policy_components,env,value);
+        axutil_array_list_add(neethi_policy->neethi_policy_components,env,value);
     }
     return AXIS2_SUCCESS;
 }
@@ -121,50 +121,50 @@
 
 
 AXIS2_EXTERN axis2_status_t AXIS2_CALL
-policy_add_operator(policy_t *policy,
+neethi_policy_add_operator(neethi_policy_t *neethi_policy,
             const axutil_env_t *env,
-            policy_operator_t *operator)
+            neethi_operator_t *operator)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
-    axutil_array_list_add(policy->policy_components,env,operator);
+    axutil_array_list_add(neethi_policy->neethi_policy_components,env,operator);
     return AXIS2_SUCCESS;
 }
 
 AXIS2_EXTERN axis2_bool_t AXIS2_CALL
-policy_is_empty(policy_t *policy,
+neethi_policy_is_empty(neethi_policy_t *neethi_policy,
             const axutil_env_t *env)
             
 {
-    return axutil_array_list_is_empty(policy->policy_components , env);
+    return axutil_array_list_is_empty(neethi_policy->neethi_policy_components , env);
 }
 
-AXIS2_EXTERN policy_exactlyone_t *AXIS2_CALL 
-policy_get_exactlyone(
-    policy_t *normalized_policy,
+AXIS2_EXTERN neethi_exactlyone_t *AXIS2_CALL 
+neethi_policy_get_exactlyone(
+    neethi_policy_t *normalized_neethi_policy,
     const axutil_env_t *env)
 {
-    policy_exactlyone_t *exactlyone = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
     axutil_array_list_t *list = NULL;
 
-    list = policy_get_policy_components(normalized_policy,env);
+    list = neethi_policy_get_policy_components(normalized_neethi_policy,env);
     if(list)
     {
         if(axutil_array_list_size(list,env)==1)
         {
-            policy_operator_t *op = NULL;
-            op = (policy_operator_t *)axutil_array_list_get(list,env,0);
+            neethi_operator_t *op = NULL;
+            op = (neethi_operator_t *)axutil_array_list_get(list,env,0);
             if(!op)
             {
-                printf("Error in normalized policy\n");
+                printf("Error in normalized neethi_policy\n");
                 return NULL;
             }               
-            if(policy_operator_get_type(op,env) != OPERATOR_TYPE_EXACTLYONE)
+            if(neethi_operator_get_type(op,env) != OPERATOR_TYPE_EXACTLYONE)
             {
-                printf("Error in normalized policy\n");
+                printf("Error in normalized neethi_policy\n");
                 return NULL;
             }               
-            exactlyone = (policy_exactlyone_t *)policy_operator_get_value(op,env);
+            exactlyone = (neethi_exactlyone_t *)neethi_operator_get_value(op,env);
             return exactlyone;
         }            
         else
@@ -175,23 +175,23 @@
 }
 
 AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL
-policy_get_alternatives(
-    policy_t *policy,
+neethi_policy_get_alternatives(
+    neethi_policy_t *neethi_policy,
     const axutil_env_t *env)
 {
 
-    policy_t *normalized = NULL;
-    policy_exactlyone_t *exactlyone = NULL;
+    neethi_policy_t *normalized = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
 
-    normalized = policy_engine_get_normalize(policy,AXIS2_FALSE,env);
+    normalized = neethi_engine_get_normalize(neethi_policy,AXIS2_FALSE,env);
 
     if(!normalized)
         return NULL;
 
-    exactlyone = policy_get_exactlyone(normalized, env);
+    exactlyone = neethi_policy_get_exactlyone(normalized, env);
     if(!exactlyone)
         return NULL;
     
-   return policy_exactlyone_get_policy_components(exactlyone, env);
+   return neethi_exactlyone_get_policy_components(exactlyone, env);
 
 }

Modified: webservices/axis2/scratch/c/neethi/src/policy_engine.c
URL: http://svn.apache.org/viewvc/webservices/axis2/scratch/c/neethi/src/policy_engine.c?view=diff&rev=529985&r1=529984&r2=529985
==============================================================================
--- webservices/axis2/scratch/c/neethi/src/policy_engine.c (original)
+++ webservices/axis2/scratch/c/neethi/src/policy_engine.c Wed Apr 18 04:24:18 2007
@@ -17,68 +17,68 @@
 
 
 
-#include <policy_engine.h>
+#include <neethi_engine.h>
 
 /*Private functions*/
 
-policy_all_t *AXIS2_CALL get_operator_all(
+neethi_all_t *AXIS2_CALL get_operator_all(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element);
 
-policy_exactlyone_t *AXIS2_CALL get_operator_exactlyone(
+neethi_exactlyone_t *AXIS2_CALL get_operator_exactlyone(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element);
 
-policy_reference_t *AXIS2_CALL get_operator_reference(
+neethi_reference_t *AXIS2_CALL get_operator_reference(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element);
 
-policy_t *AXIS2_CALL get_operator_policy(
+neethi_policy_t *AXIS2_CALL get_operator_neethi_policy(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element);
 
 axis2_status_t AXIS2_CALL process_operation_element(
         const axutil_env_t *env,
-        policy_operator_t *policy_operator,
+        neethi_operator_t *neethi_operator,
         axiom_node_t *node,
         axiom_element_t *element);
 
-axis2_status_t AXIS2_CALL policy_engine_add_policy_component(
+axis2_status_t AXIS2_CALL neethi_engine_add_policy_component(
         const axutil_env_t *env,
-        policy_operator_t *container_operator,
-        policy_operator_t *component);
+        neethi_operator_t *container_operator,
+        neethi_operator_t *component);
 
 axis2_bool_t AXIS2_CALL
 operator_is_empty(
-    policy_operator_t *operator,
+    neethi_operator_t *operator,
     const axutil_env_t *env);
 
-policy_exactlyone_t *AXIS2_CALL
+neethi_exactlyone_t *AXIS2_CALL
 compute_resultant_component(
     axutil_array_list_t *normalized_inner_components,
-    policy_operator_type_t type,
+    neethi_operator_type_t type,
     const axutil_env_t *env);
 
 axutil_array_list_t *AXIS2_CALL
 operator_get_components(
-    policy_operator_t *operator,
+    neethi_operator_t *operator,
     const axutil_env_t *env);
 
-policy_exactlyone_t *AXIS2_CALL
+neethi_exactlyone_t *AXIS2_CALL
 normalize_operator(
-    policy_operator_t *operator,
-    policy_registry_t *registry,
+    neethi_operator_t *operator,
+    neethi_registry_t *registry,
     axis2_bool_t deep,
     const axutil_env_t *env);
 
-policy_exactlyone_t *AXIS2_CALL
+neethi_exactlyone_t *AXIS2_CALL
 get_cross_product(
-    policy_exactlyone_t *exactlyone1,
-    policy_exactlyone_t *exactlyone2,
+    neethi_exactlyone_t *exactlyone1,
+    neethi_exactlyone_t *exactlyone2,
     const axutil_env_t *env);
 
 
@@ -86,83 +86,83 @@
 /*Implementations*/
 
 
-AXIS2_EXTERN policy_t *AXIS2_CALL
-policy_engine_get_policy(
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_engine_get_policy(
     const axutil_env_t *env,
     axiom_node_t *node,
     axiom_element_t *element)
 {
 
-    return get_operator_policy(env,node,element);    
+    return get_operator_neethi_policy(env,node,element);    
 
 }
 
-policy_all_t *AXIS2_CALL get_operator_all(
+neethi_all_t *AXIS2_CALL get_operator_all(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element)
 {
-    policy_all_t *all = NULL;
-    policy_operator_t *policy_operator = NULL;
+    neethi_all_t *all = NULL;
+    neethi_operator_t *neethi_operator = NULL;
 
-    all = policy_all_create(env);
+    all = neethi_all_create(env);
 
     if(!all)
     {
         return NULL;
     }
-    policy_operator = policy_operator_create(env);
-    if(!policy_operator)
+    neethi_operator = neethi_operator_create(env);
+    if(!neethi_operator)
     {
         return NULL;
     }        
-    policy_operator_set_value(policy_operator,env,all,OPERATOR_TYPE_ALL);
-    process_operation_element(env,policy_operator,node,element);
+    neethi_operator_set_value(neethi_operator,env,all,OPERATOR_TYPE_ALL);
+    process_operation_element(env,neethi_operator,node,element);
 
     return all;
 }   
 
-policy_exactlyone_t *AXIS2_CALL get_operator_exactlyone(
+neethi_exactlyone_t *AXIS2_CALL get_operator_exactlyone(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element)
 {
-    policy_exactlyone_t *exactlyone = NULL;
-    policy_operator_t *policy_operator = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_operator_t *neethi_operator = NULL;
 
-    exactlyone = policy_exactlyone_create(env);
+    exactlyone = neethi_exactlyone_create(env);
 
     if(!exactlyone)
     {
         return NULL;
     }
-    policy_operator = policy_operator_create(env);
-    if(!policy_operator)
+    neethi_operator = neethi_operator_create(env);
+    if(!neethi_operator)
     {
         return NULL;
     }        
-    policy_operator_set_value(policy_operator,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
-    process_operation_element(env,policy_operator,node,element);
+    neethi_operator_set_value(neethi_operator,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
+    process_operation_element(env,neethi_operator,node,element);
 
     return exactlyone;
 }
 
-policy_reference_t *AXIS2_CALL get_operator_reference(
+neethi_reference_t *AXIS2_CALL get_operator_reference(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element)
 {
-    policy_reference_t *reference = NULL;
+    neethi_reference_t *reference = NULL;
     axutil_qname_t *qname = NULL;
     axis2_char_t * attribute_value = NULL;
 
-    reference = policy_reference_create(env);
+    reference = neethi_reference_create(env);
 
     if(!reference)
     {
         return NULL;
     }
-    qname = axutil_qname_create(env,POLICY_URI,NULL,NULL);
+    qname = axutil_qname_create(env,NEETHI_URI,NULL,NULL);
 
     if(!qname)
     {
@@ -172,54 +172,54 @@
     attribute_value = axiom_element_get_attribute_value(element,env,qname);
     if(attribute_value)
     {
-        policy_reference_set_uri(reference,env,attribute_value);
+        neethi_reference_set_uri(reference,env,attribute_value);
     }    
     return reference;
 }
 
 
 
-policy_t *AXIS2_CALL get_operator_policy(
+neethi_policy_t *AXIS2_CALL get_operator_neethi_policy(
         const axutil_env_t *env,
         axiom_node_t *node,
         axiom_element_t *element)
 {
-    policy_t *policy = NULL;
-    policy_operator_t *policy_operator = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_operator_t *neethi_operator = NULL;
 
-    policy = policy_create(env);
+    neethi_policy = neethi_policy_create(env);
 
-    if(!policy)
+    if(!neethi_policy)
     {
         return NULL;
     }
-    policy_operator = policy_operator_create(env);
-    if(!policy_operator)
+    neethi_operator = neethi_operator_create(env);
+    if(!neethi_operator)
     {
         return NULL;
     }        
-    policy_operator_set_value(policy_operator,env,policy,OPERATOR_TYPE_POLICY);
-    process_operation_element(env,policy_operator,node,element);    
+    neethi_operator_set_value(neethi_operator,env,neethi_policy,OPERATOR_TYPE_POLICY);
+    process_operation_element(env,neethi_operator,node,element);    
 
-    return policy;
+    return neethi_policy;
 }
 
 
 axis2_status_t AXIS2_CALL process_operation_element(
         const axutil_env_t *env,
-        policy_operator_t *policy_operator,
+        neethi_operator_t *neethi_operator,
         axiom_node_t *node,
         axiom_element_t *element)
 {
 
-    policy_operator_type_t type;
+    neethi_operator_type_t type;
     axiom_element_t *child_element = NULL;
     axiom_node_t *child_node = NULL;
     axiom_children_iterator_t *children_iter = NULL;
     void *value = NULL;
 
-    type = policy_operator_get_type(policy_operator,env);
-    value = policy_operator_get_value(policy_operator,env);
+    type = neethi_operator_get_type(neethi_operator,env);
+    value = neethi_operator_get_value(neethi_operator,env);
     if(type == OPERATOR_TYPE_POLICY)
     {
         /*Adding attribute values to the hashmap logic
@@ -241,38 +241,38 @@
                     if(child_element)
                     {
                         axis2_char_t *local_name = NULL;
-                        policy_operator_t *operator = NULL;
+                        neethi_operator_t *operator = NULL;
                         local_name = axiom_element_get_localname(child_element,env);
 
-                        if(axutil_strcmp(local_name,POLICY_POLICY)==0)
+                        if(axutil_strcmp(local_name,NEETHI_POLICY)==0)
                         {
-                            policy_t *policy = get_operator_policy(env,child_node,child_element);
-                            operator = policy_operator_create(env);
-                            policy_operator_set_value(operator,env,policy,OPERATOR_TYPE_POLICY);
-                            policy_engine_add_policy_component(env,policy_operator,operator);
+                            neethi_policy_t *neethi_policy = get_operator_neethi_policy(env,child_node,child_element);
+                            operator = neethi_operator_create(env);
+                            neethi_operator_set_value(operator,env,neethi_policy,OPERATOR_TYPE_POLICY);
+                            neethi_engine_add_policy_component(env,neethi_operator,operator);
                         }
 
-                        else if(axutil_strcmp(local_name,POLICY_ALL)==0)
+                        else if(axutil_strcmp(local_name,NEETHI_ALL)==0)
                         {
-                            policy_all_t *all = get_operator_all(env,child_node,child_element);
-                            operator = policy_operator_create(env);
-                            policy_operator_set_value(operator,env,all,OPERATOR_TYPE_ALL);
-                            policy_engine_add_policy_component(env,policy_operator,operator);
+                            neethi_all_t *all = get_operator_all(env,child_node,child_element);
+                            operator = neethi_operator_create(env);
+                            neethi_operator_set_value(operator,env,all,OPERATOR_TYPE_ALL);
+                            neethi_engine_add_policy_component(env,neethi_operator,operator);
                         }
 
-                        else if(axutil_strcmp(local_name,POLICY_EXACTLYONE)==0)
+                        else if(axutil_strcmp(local_name,NEETHI_EXACTLYONE)==0)
                         {
-                            policy_exactlyone_t *exactlyone = get_operator_exactlyone(env,child_node,child_element);
-                            operator = policy_operator_create(env);
-                            policy_operator_set_value(operator,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
-                            policy_engine_add_policy_component(env,policy_operator,operator);
+                            neethi_exactlyone_t *exactlyone = get_operator_exactlyone(env,child_node,child_element);
+                            operator = neethi_operator_create(env);
+                            neethi_operator_set_value(operator,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
+                            neethi_engine_add_policy_component(env,neethi_operator,operator);
                         }
-                        else if(axutil_strcmp(local_name,POLICY_REFERENCE)==0)
+                        else if(axutil_strcmp(local_name,NEETHI_REFERENCE)==0)
                         {
-                            policy_reference_t *reference = get_operator_reference(env,child_node,child_element);
-                            operator = policy_operator_create(env);
-                            policy_operator_set_value(operator,env,reference,OPERATOR_TYPE_REFERENCE);
-                            policy_engine_add_policy_component(env,policy_operator,operator);
+                            neethi_reference_t *reference = get_operator_reference(env,child_node,child_element);
+                            operator = neethi_operator_create(env);
+                            neethi_operator_set_value(operator,env,reference,OPERATOR_TYPE_REFERENCE);
+                            neethi_engine_add_policy_component(env,neethi_operator,operator);
                         }                        
                         else
                             return AXIS2_FAILURE;
@@ -285,40 +285,40 @@
 }
 
 
-axis2_status_t AXIS2_CALL policy_engine_add_policy_component(
+axis2_status_t AXIS2_CALL neethi_engine_add_policy_component(
         const axutil_env_t *env,
-        policy_operator_t *container_operator,
-        policy_operator_t *component)
+        neethi_operator_t *container_operator,
+        neethi_operator_t *component)
 {
 
-    policy_operator_type_t type;
+    neethi_operator_type_t type;
     void *value = NULL;
-    policy_t *policy = NULL;
-    policy_exactlyone_t *exactlyone = NULL;
-    policy_all_t *all = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_all_t *all = NULL;
 
-    type = policy_operator_get_type(container_operator,env);
-    value = policy_operator_get_value(container_operator,env);        
+    type = neethi_operator_get_type(container_operator,env);
+    value = neethi_operator_get_value(container_operator,env);        
     
     if(value)
     {
         switch(type)
         {
             case OPERATOR_TYPE_POLICY:
-                policy = (policy_t *)value;
-                policy_add_operator(policy,env,component);   
-                printf("policy\n");
+                neethi_policy = (neethi_policy_t *)value;
+                neethi_policy_add_operator(neethi_policy,env,component);   
+                printf("neethi_policy\n");
                 break;
 
             case OPERATOR_TYPE_ALL:
-                all = (policy_all_t *)value;
-                policy_all_add_operator(all,env,component);
+                all = (neethi_all_t *)value;
+                neethi_all_add_operator(all,env,component);
                 printf("all\n");
                 break;
 
             case OPERATOR_TYPE_EXACTLYONE:
-                exactlyone = (policy_exactlyone_t *)value;
-                policy_exactlyone_add_operator(exactlyone,env,component);
+                exactlyone = (neethi_exactlyone_t *)value;
+                neethi_exactlyone_add_operator(exactlyone,env,component);
                 printf("exactlyone\n");
                 break;
 
@@ -334,24 +334,24 @@
 /***************************************/
 /*This function is only for testing*
  *Remove it later*/
-void check_policy(policy_t *policy , const axutil_env_t *env)
+void check_neethi_policy(neethi_policy_t *neethi_policy , const axutil_env_t *env)
 {
     axutil_array_list_t *list = NULL;
-    policy_operator_t *op = NULL;
-    policy_operator_type_t type;
+    neethi_operator_t *op = NULL;
+    neethi_operator_type_t type;
 
-    list = policy_get_policy_components(policy,env);
+    list = neethi_policy_get_policy_components(neethi_policy,env);
 
     if(axutil_array_list_size(list,env)>1)
     {
-        printf("Error with Normalized policy\n");
+        printf("Error with Normalized neethi_policy\n");
         return;
     }        
-    op = (policy_operator_t *)axutil_array_list_get(list,env,0);
-    type = policy_operator_get_type(op,env);
+    op = (neethi_operator_t *)axutil_array_list_get(list,env,0);
+    type = neethi_operator_get_type(op,env);
     if(type == OPERATOR_TYPE_EXACTLYONE)
     {
-        void *value = policy_operator_get_value(op,env);
+        void *value = neethi_operator_get_value(op,env);
         if(value)
         {
             printf("Check is ok\n");
@@ -367,62 +367,62 @@
 
 /************************************************/
 
-AXIS2_EXTERN policy_t *AXIS2_CALL
-policy_engine_get_normalize(
-        policy_t *policy,
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_engine_get_normalize(
+        neethi_policy_t *neethi_policy,
         axis2_bool_t deep,
         const axutil_env_t *env)
 {
-    return policy_engine_normalize(policy, NULL, deep, env);
+    return neethi_engine_normalize(neethi_policy, NULL, deep, env);
 }
 
 
-AXIS2_EXTERN policy_t *AXIS2_CALL
-policy_engine_normalize(
-    policy_t *policy,
-    policy_registry_t *registry,
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_engine_normalize(
+    neethi_policy_t *neethi_policy,
+    neethi_registry_t *registry,
     axis2_bool_t deep,
     const axutil_env_t *env)
 {
-    policy_t *resultant_policy = NULL;
-    policy_operator_t *operator = NULL;
-    policy_operator_t *component = NULL;
-    policy_exactlyone_t *exactlyone = NULL;
-
-    resultant_policy = policy_create(env);
-    operator = policy_operator_create(env);
-    policy_operator_set_value(operator,env,policy,OPERATOR_TYPE_POLICY);
+    neethi_policy_t *resultant_neethi_policy = NULL;
+    neethi_operator_t *operator = NULL;
+    neethi_operator_t *component = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+
+    resultant_neethi_policy = neethi_policy_create(env);
+    operator = neethi_operator_create(env);
+    neethi_operator_set_value(operator,env,neethi_policy,OPERATOR_TYPE_POLICY);
 
     exactlyone = normalize_operator(operator,registry,deep,env);
 
     if(exactlyone)
     {
-        component = policy_operator_create(env);
-        policy_operator_set_value(component,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
-        policy_add_operator(resultant_policy,env,component);
+        component = neethi_operator_create(env);
+        neethi_operator_set_value(component,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
+        neethi_policy_add_operator(resultant_neethi_policy,env,component);
         
-        check_policy(resultant_policy,env);
-        return resultant_policy;
+        check_neethi_policy(resultant_neethi_policy,env);
+        return resultant_neethi_policy;
     }        
     else
         return NULL;
 }
 
-AXIS2_EXTERN policy_t *AXIS2_CALL
-policy_engine_merge(
-    policy_t *policy1,
-    policy_t *policy2,
+AXIS2_EXTERN neethi_policy_t *AXIS2_CALL
+neethi_engine_merge(
+    neethi_policy_t *neethi_policy1,
+    neethi_policy_t *neethi_policy2,
     const axutil_env_t *env)
 {
 
-    policy_exactlyone_t *exactlyone1 = NULL;
-    policy_exactlyone_t *exactlyone2 = NULL;
-    policy_exactlyone_t *exactlyone = NULL;
-    policy_t *policy = NULL;
-    policy_operator_t *component = NULL;
+    neethi_exactlyone_t *exactlyone1 = NULL;
+    neethi_exactlyone_t *exactlyone2 = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_operator_t *component = NULL;
 
-    exactlyone1 = policy_get_exactlyone(policy1,env);
-    exactlyone2 = policy_get_exactlyone(policy2,env);    
+    exactlyone1 = neethi_policy_get_exactlyone(neethi_policy1,env);
+    exactlyone2 = neethi_policy_get_exactlyone(neethi_policy2,env);    
 
     if(!exactlyone1 || !exactlyone2)
     {
@@ -431,49 +431,49 @@
     }
     exactlyone = get_cross_product(exactlyone1,exactlyone2,env);
     
-    policy = policy_create(env);
+    neethi_policy = neethi_policy_create(env);
 
-    component = policy_operator_create(env);
-    policy_operator_set_value(component,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
-    policy_add_operator(policy,env,component);
+    component = neethi_operator_create(env);
+    neethi_operator_set_value(component,env,exactlyone,OPERATOR_TYPE_EXACTLYONE);
+    neethi_policy_add_operator(neethi_policy,env,component);
 
-    return policy;
+    return neethi_policy;
 }
 
 
 
 axis2_bool_t AXIS2_CALL 
 operator_is_empty(
-    policy_operator_t *operator,
+    neethi_operator_t *operator,
     const axutil_env_t *env)
 {
     
-    policy_operator_type_t type;
+    neethi_operator_type_t type;
     void *value = NULL;
-    policy_t *policy = NULL;
-    policy_exactlyone_t *exactlyone = NULL;
-    policy_all_t *all = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_all_t *all = NULL;
 
-    type = policy_operator_get_type(operator,env);
-    value = policy_operator_get_value(operator,env);
+    type = neethi_operator_get_type(operator,env);
+    value = neethi_operator_get_value(operator,env);
 
     if(value)
     {
         switch(type)
         {
             case OPERATOR_TYPE_POLICY:
-                policy = (policy_t *)value;
-                return policy_is_empty(policy,env);
+                neethi_policy = (neethi_policy_t *)value;
+                return neethi_policy_is_empty(neethi_policy,env);
                 break;
 
             case OPERATOR_TYPE_ALL:
-                all = (policy_all_t *)value;
-                return policy_all_is_empty(all,env);
+                all = (neethi_all_t *)value;
+                return neethi_all_is_empty(all,env);
                 break;
 
             case OPERATOR_TYPE_EXACTLYONE:
-                exactlyone = (policy_exactlyone_t *)value;
-                return policy_exactlyone_is_empty(exactlyone,env);
+                exactlyone = (neethi_exactlyone_t *)value;
+                return neethi_exactlyone_is_empty(exactlyone,env);
                 break;
 
             case OPERATOR_TYPE_UNKNOWN:
@@ -487,36 +487,36 @@
 
 axutil_array_list_t *AXIS2_CALL 
 operator_get_components(
-    policy_operator_t *operator,
+    neethi_operator_t *operator,
     const axutil_env_t *env)
 {
     
-    policy_operator_type_t type;
+    neethi_operator_type_t type;
     void *value = NULL;
-    policy_t *policy = NULL;
-    policy_exactlyone_t *exactlyone = NULL;
-    policy_all_t *all = NULL;
+    neethi_policy_t *neethi_policy = NULL;
+    neethi_exactlyone_t *exactlyone = NULL;
+    neethi_all_t *all = NULL;
 
-    type = policy_operator_get_type(operator,env);
-    value = policy_operator_get_value(operator,env);
+    type = neethi_operator_get_type(operator,env);
+    value = neethi_operator_get_value(operator,env);
 
     if(value)
     {
         switch(type)
         {
             case OPERATOR_TYPE_POLICY:
-                policy = (policy_t *)value;
-                return policy_get_policy_components(policy,env);
+                neethi_policy = (neethi_policy_t *)value;
+                return neethi_policy_get_policy_components(neethi_policy,env);
                 break;
 
             case OPERATOR_TYPE_ALL:
-                all = (policy_all_t *)value;
-                return policy_all_get_policy_components(all,env);
+                all = (neethi_all_t *)value;
+                return neethi_all_get_policy_components(all,env);
                 break;
 
             case OPERATOR_TYPE_EXACTLYONE:
-                exactlyone = (policy_exactlyone_t *)value;
-                return policy_exactlyone_get_policy_components(exactlyone,env);
+                exactlyone = (neethi_exactlyone_t *)value;
+                return neethi_exactlyone_get_policy_components(exactlyone,env);
                 break;
 
             case OPERATOR_TYPE_UNKNOWN:
@@ -529,32 +529,32 @@
 
 
 
-policy_exactlyone_t *AXIS2_CALL
+neethi_exactlyone_t *AXIS2_CALL
 normalize_operator(
-    policy_operator_t *operator,
-    policy_registry_t *registry,
+    neethi_operator_t *operator,
+    neethi_registry_t *registry,
     axis2_bool_t deep,
     const axutil_env_t *env)
 {
     axutil_array_list_t *child_component_list = NULL;
-    policy_operator_t *child_component = NULL;
+    neethi_operator_t *child_component = NULL;
     axutil_array_list_t *arraylist = NULL;
     int i = 0;
 
-    policy_operator_type_t type = policy_operator_get_type(operator,env);
+    neethi_operator_type_t type = neethi_operator_get_type(operator,env);
     
     if(operator_is_empty(operator,env))
     {
-        policy_exactlyone_t *exactlyone = NULL;
-        exactlyone = policy_exactlyone_create(env);
+        neethi_exactlyone_t *exactlyone = NULL;
+        exactlyone = neethi_exactlyone_create(env);
         if(type != OPERATOR_TYPE_EXACTLYONE)
         {
-            policy_all_t *all = NULL;
-            policy_operator_t *component = NULL;
-            all = policy_all_create(env);
-            component = policy_operator_create(env);
-            policy_operator_set_value(component,env,all,OPERATOR_TYPE_ALL);
-            policy_exactlyone_add_operator(exactlyone,env,component);
+            neethi_all_t *all = NULL;
+            neethi_operator_t *component = NULL;
+            all = neethi_all_create(env);
+            component = neethi_operator_create(env);
+            neethi_operator_set_value(component,env,all,OPERATOR_TYPE_ALL);
+            neethi_exactlyone_add_operator(exactlyone,env,component);
         }                        
         return exactlyone;
     }
@@ -564,9 +564,9 @@
 
     for (i = 0; i < axutil_array_list_size(arraylist,env); i++)
     {
-        policy_operator_type_t component_type;
-        child_component = (policy_operator_t *)axutil_array_list_get(arraylist ,env ,i);
-        component_type = policy_operator_get_type(child_component,env);
+        neethi_operator_type_t component_type;
+        child_component = (neethi_operator_t *)axutil_array_list_get(arraylist ,env ,i);
+        component_type = neethi_operator_get_type(child_component,env);
         
         if(component_type == OPERATOR_TYPE_ASSERTION)
         {
@@ -576,17 +576,17 @@
         else if(component_type == OPERATOR_TYPE_REFERENCE)
         {
             axis2_char_t *uri = NULL;
-            policy_reference_t *pol_ref = NULL;
-            policy_t *policy = NULL;
+            neethi_reference_t *pol_ref = NULL;
+            neethi_policy_t *neethi_policy = NULL;
 
-            pol_ref = (policy_reference_t *)policy_operator_get_value(child_component,env);
-            uri = policy_reference_get_uri(pol_ref,env);
+            pol_ref = (neethi_reference_t *)neethi_operator_get_value(child_component,env);
+            uri = neethi_reference_get_uri(pol_ref,env);
             if(uri)
             {
-                policy = policy_registry_lookup(registry,env,uri);
-                if(policy)
+                neethi_policy = neethi_registry_lookup(registry,env,uri);
+                if(neethi_policy)
                 {
-                    policy_operator_set_value(child_component,env,policy,OPERATOR_TYPE_POLICY);
+                    neethi_operator_set_value(child_component,env,neethi_policy,OPERATOR_TYPE_POLICY);
                     component_type = OPERATOR_TYPE_POLICY;
                 }
                 else
@@ -598,24 +598,24 @@
         }
         else if(component_type == OPERATOR_TYPE_POLICY)
         {
-            policy_t *policy = NULL;
-            policy_all_t *all = NULL;
+            neethi_policy_t *neethi_policy = NULL;
+            neethi_all_t *all = NULL;
             axutil_array_list_t *children = NULL;            
-            policy_operator_t *to_normalize = NULL;
-            policy_exactlyone_t *exactlyone = NULL;
+            neethi_operator_t *to_normalize = NULL;
+            neethi_exactlyone_t *exactlyone = NULL;
 
-            all = policy_all_create(env);
-            policy = (policy_t *)policy_operator_get_value(child_component,env);
-            children =  policy_get_policy_components(policy,env);
-            policy_all_add_policy_components(all,children,env);
-            to_normalize = policy_operator_create(env);
-            policy_operator_set_value(to_normalize,env,all,OPERATOR_TYPE_ALL);
+            all = neethi_all_create(env);
+            neethi_policy = (neethi_policy_t *)neethi_operator_get_value(child_component,env);
+            children =  neethi_policy_get_policy_components(neethi_policy,env);
+            neethi_all_add_policy_components(all,children,env);
+            to_normalize = neethi_operator_create(env);
+            neethi_operator_set_value(to_normalize,env,all,OPERATOR_TYPE_ALL);
             exactlyone = normalize_operator(to_normalize,registry,deep,env);
             axutil_array_list_add(child_component_list,env,exactlyone);                    
         }
         else
         {
-            policy_exactlyone_t *exactlyone = NULL;
+            neethi_exactlyone_t *exactlyone = NULL;
             exactlyone = normalize_operator(child_component,registry,deep,env);
             axutil_array_list_add(child_component_list,env,exactlyone);
         }
@@ -624,25 +624,25 @@
 }
 
 
-policy_exactlyone_t *AXIS2_CALL
+neethi_exactlyone_t *AXIS2_CALL
 compute_resultant_component(
     axutil_array_list_t *normalized_inner_components,
-    policy_operator_type_t type,
+    neethi_operator_type_t type,
     const axutil_env_t *env)
 {
-    policy_exactlyone_t *exactlyone = NULL;
-    exactlyone = policy_exactlyone_create(env);
+    neethi_exactlyone_t *exactlyone = NULL;
+    exactlyone = neethi_exactlyone_create(env);
 
     if(type == OPERATOR_TYPE_EXACTLYONE)
     {
         int i = 0;
-        policy_exactlyone_t *inner_exactlyone = NULL;
+        neethi_exactlyone_t *inner_exactlyone = NULL;
         
         for(i=0; i<axutil_array_list_size(normalized_inner_components,env); i++ )
         {
-            inner_exactlyone = (policy_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,i);
-            policy_exactlyone_add_policy_components(exactlyone,
-                           policy_exactlyone_get_policy_components(inner_exactlyone,env),env);
+            inner_exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,i);
+            neethi_exactlyone_add_policy_components(exactlyone,
+                           neethi_exactlyone_get_policy_components(inner_exactlyone,env),env);
             
         }
     }
@@ -652,15 +652,15 @@
         if(axutil_array_list_size(normalized_inner_components,env)>1)
         {
             int i = 0;
-            exactlyone = (policy_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,0);
-            if(!policy_exactlyone_is_empty(exactlyone,env))
+            exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,0);
+            if(!neethi_exactlyone_is_empty(exactlyone,env))
             {
-                policy_exactlyone_t *current_exactlyone = NULL;
+                neethi_exactlyone_t *current_exactlyone = NULL;
                 i = 1;
                 for(i=1; i<axutil_array_list_size(normalized_inner_components,env); i++)
                 {
-                    current_exactlyone = (policy_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,i);
-                    if(policy_exactlyone_is_empty(current_exactlyone,env)) 
+                    current_exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,i);
+                    if(neethi_exactlyone_is_empty(current_exactlyone,env)) 
                     {
                         exactlyone = current_exactlyone;
                         break;    
@@ -671,52 +671,52 @@
             }
         }
         else
-            exactlyone = (policy_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,0);    
+            exactlyone = (neethi_exactlyone_t *)axutil_array_list_get(normalized_inner_components,env,0);    
     }
     return exactlyone;
 }
 
 
-policy_exactlyone_t *AXIS2_CALL
+neethi_exactlyone_t *AXIS2_CALL
 get_cross_product(
-    policy_exactlyone_t *exactlyone1,
-    policy_exactlyone_t *exactlyone2,
+    neethi_exactlyone_t *exactlyone1,
+    neethi_exactlyone_t *exactlyone2,
     const axutil_env_t *env)
 {
-    policy_exactlyone_t *cross_product = NULL;
-    policy_all_t *cross_product_all = NULL;
-    policy_all_t *current_all1 = NULL;
-    policy_all_t *current_all2 = NULL;
+    neethi_exactlyone_t *cross_product = NULL;
+    neethi_all_t *cross_product_all = NULL;
+    neethi_all_t *current_all1 = NULL;
+    neethi_all_t *current_all2 = NULL;
     axutil_array_list_t *array_list1 = NULL;
     axutil_array_list_t *array_list2 = NULL;
-    policy_operator_t *component = NULL;
+    neethi_operator_t *component = NULL;
     int i = 0;
     int j = 0;
 
-    cross_product = policy_exactlyone_create(env);
-    array_list1 = policy_exactlyone_get_policy_components(exactlyone1,env);
-    array_list2 = policy_exactlyone_get_policy_components(exactlyone2,env);
+    cross_product = neethi_exactlyone_create(env);
+    array_list1 = neethi_exactlyone_get_policy_components(exactlyone1,env);
+    array_list2 = neethi_exactlyone_get_policy_components(exactlyone2,env);
 
     for(i=0; i<axutil_array_list_size(array_list1,env); i++)
     {
-        current_all1 = (policy_all_t *)policy_operator_get_value(
-           (policy_operator_t *)axutil_array_list_get(array_list1,env,i), env );
+        current_all1 = (neethi_all_t *)neethi_operator_get_value(
+           (neethi_operator_t *)axutil_array_list_get(array_list1,env,i), env );
         
         for(j=0; j<axutil_array_list_size(array_list2,env); j++ )
         {
-            current_all2 = (policy_all_t *)policy_operator_get_value(
-                (policy_operator_t *)axutil_array_list_get(array_list2,env,j), env );
+            current_all2 = (neethi_all_t *)neethi_operator_get_value(
+                (neethi_operator_t *)axutil_array_list_get(array_list2,env,j), env );
             
-            cross_product_all = policy_all_create(env);
-            policy_all_add_policy_components(cross_product_all,
-                           policy_all_get_policy_components(current_all1,env),env);
+            cross_product_all = neethi_all_create(env);
+            neethi_all_add_policy_components(cross_product_all,
+                           neethi_all_get_policy_components(current_all1,env),env);
             
-            policy_all_add_policy_components(cross_product_all,
-                           policy_all_get_policy_components(current_all2,env),env);
+            neethi_all_add_policy_components(cross_product_all,
+                           neethi_all_get_policy_components(current_all2,env),env);
             
-            component = policy_operator_create(env);
-            policy_operator_set_value(component,env,cross_product_all,OPERATOR_TYPE_ALL);
-            policy_exactlyone_add_operator(cross_product,env,component);
+            component = neethi_operator_create(env);
+            neethi_operator_set_value(component,env,cross_product_all,OPERATOR_TYPE_ALL);
+            neethi_exactlyone_add_operator(cross_product,env,component);
         }
 
     }



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