You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by sa...@apache.org on 2007/04/18 13:24:19 UTC
svn commit: r529985 [1/2] - in /webservices/axis2/scratch/c/neethi: include/
src/ src/secpolicy/builder/
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