4
* adb_configureNetworkType.c
6
* This file was auto-generated from WSDL
7
* by the Apache Axis2/C version: SNAPSHOT Built on : Mar 10, 2008 (08:35:52 GMT+00:00)
10
#include "adb_configureNetworkType.h"
13
* This type was generated from the piece of schema that had
14
* name = configureNetworkType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_configureNetworkType
23
axis2_char_t* property_correlationId;
26
axis2_bool_t is_valid_correlationId;
29
axis2_char_t* property_userId;
32
axis2_bool_t is_valid_userId;
35
axis2_char_t* property_statusMessage;
38
axis2_bool_t is_valid_statusMessage;
41
axis2_bool_t property_return;
44
axis2_bool_t is_valid_return;
47
axutil_array_list_t* property_rules;
50
axis2_bool_t is_valid_rules;
57
/************************* Private Function prototypes ********************************/
60
axis2_status_t AXIS2_CALL
61
adb_configureNetworkType_set_correlationId_nil(
62
adb_configureNetworkType_t* _configureNetworkType,
63
const axutil_env_t *env);
66
axis2_status_t AXIS2_CALL
67
adb_configureNetworkType_set_userId_nil(
68
adb_configureNetworkType_t* _configureNetworkType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_configureNetworkType_set_return_nil(
74
adb_configureNetworkType_t* _configureNetworkType,
75
const axutil_env_t *env);
77
axis2_status_t AXIS2_CALL
78
adb_configureNetworkType_set_rules_nil_at(
79
adb_configureNetworkType_t* _configureNetworkType,
80
const axutil_env_t *env, int i);
83
axis2_status_t AXIS2_CALL
84
adb_configureNetworkType_set_rules_nil(
85
adb_configureNetworkType_t* _configureNetworkType,
86
const axutil_env_t *env);
90
/************************* Function Implmentations ********************************/
91
adb_configureNetworkType_t* AXIS2_CALL
92
adb_configureNetworkType_create(
93
const axutil_env_t *env)
95
adb_configureNetworkType_t *_configureNetworkType = NULL;
97
AXIS2_ENV_CHECK(env, NULL);
99
_configureNetworkType = (adb_configureNetworkType_t *) AXIS2_MALLOC(env->
100
allocator, sizeof(adb_configureNetworkType_t));
102
if(NULL == _configureNetworkType)
104
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
108
memset(_configureNetworkType, 0, sizeof(adb_configureNetworkType_t));
110
_configureNetworkType->property_correlationId = NULL;
111
_configureNetworkType->is_valid_correlationId = AXIS2_FALSE;
112
_configureNetworkType->property_userId = NULL;
113
_configureNetworkType->is_valid_userId = AXIS2_FALSE;
114
_configureNetworkType->property_statusMessage = NULL;
115
_configureNetworkType->is_valid_statusMessage = AXIS2_FALSE;
116
_configureNetworkType->is_valid_return = AXIS2_FALSE;
117
_configureNetworkType->property_rules = NULL;
118
_configureNetworkType->is_valid_rules = AXIS2_FALSE;
121
return _configureNetworkType;
124
axis2_status_t AXIS2_CALL
125
adb_configureNetworkType_free (
126
adb_configureNetworkType_t* _configureNetworkType,
127
const axutil_env_t *env)
132
void *element = NULL;
135
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
136
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
138
adb_configureNetworkType_reset_correlationId(_configureNetworkType, env);
139
adb_configureNetworkType_reset_userId(_configureNetworkType, env);
140
adb_configureNetworkType_reset_statusMessage(_configureNetworkType, env);
141
adb_configureNetworkType_reset_return(_configureNetworkType, env);
142
adb_configureNetworkType_reset_rules(_configureNetworkType, env);
145
if(_configureNetworkType)
147
AXIS2_FREE(env->allocator, _configureNetworkType);
148
_configureNetworkType = NULL;
150
return AXIS2_SUCCESS;
156
axis2_status_t AXIS2_CALL
157
adb_configureNetworkType_deserialize(
158
adb_configureNetworkType_t* _configureNetworkType,
159
const axutil_env_t *env,
160
axiom_node_t **dp_parent,
161
axis2_bool_t *dp_is_early_node_valid,
162
axis2_bool_t dont_care_minoccurs)
164
axiom_node_t *parent = *dp_parent;
166
axis2_status_t status = AXIS2_SUCCESS;
168
void *element = NULL;
170
axis2_char_t* text_value = NULL;
171
axutil_qname_t *qname = NULL;
174
axutil_array_list_t *arr_list = NULL;
176
int sequence_broken = 0;
177
axiom_node_t *tmp_node = NULL;
179
axutil_qname_t *element_qname = NULL;
181
axiom_node_t *first_node = NULL;
182
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
183
axiom_node_t *current_node = NULL;
184
axiom_element_t *current_element = NULL;
186
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
187
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
191
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
193
parent = axiom_node_get_next_sibling(parent, env);
197
/* This should be checked before everything */
198
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
199
"Failed in building adb object for configureNetworkType : "
200
"NULL elemenet can not be passed to deserialize");
201
return AXIS2_FAILURE;
205
first_node = axiom_node_get_first_child(parent, env);
211
* building correlationId element
216
current_node = first_node;
217
is_early_node_valid = AXIS2_FALSE;
220
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
222
current_node = axiom_node_get_next_sibling(current_node, env);
224
if(current_node != NULL)
226
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
227
qname = axiom_element_get_qname(current_element, env, current_node);
230
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
234
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
236
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
238
is_early_node_valid = AXIS2_TRUE;
242
text_value = axiom_element_get_text(current_element, env, current_node);
243
if(text_value != NULL)
245
status = adb_configureNetworkType_set_correlationId(_configureNetworkType, env,
252
* axis2_qname_t *qname = NULL;
253
* axiom_attribute_t *the_attri = NULL;
255
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
256
* the_attri = axiom_element_get_attribute(current_element, env, qname);
258
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
260
axiom_attribute_t *the_attri = NULL;
261
axis2_char_t *attrib_text = NULL;
262
axutil_hash_t *attribute_hash = NULL;
264
attribute_hash = axiom_element_get_all_attributes(current_element, env);
269
axutil_hash_index_t *hi;
273
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
275
axutil_hash_this(hi, &key, NULL, &val);
277
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
279
the_attri = (axiom_attribute_t*)val;
287
attrib_text = axiom_attribute_get_value(the_attri, env);
291
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
292
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
295
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
297
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
298
status = AXIS2_FAILURE;
302
/* after all, we found this is a empty string */
303
status = adb_configureNetworkType_set_correlationId(_configureNetworkType, env,
308
if(AXIS2_FAILURE == status)
310
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
313
axutil_qname_free(element_qname, env);
315
return AXIS2_FAILURE;
321
axutil_qname_free(element_qname, env);
322
element_qname = NULL;
328
* building userId element
334
* because elements are ordered this works fine
338
if(current_node != NULL && is_early_node_valid)
340
current_node = axiom_node_get_next_sibling(current_node, env);
343
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
345
current_node = axiom_node_get_next_sibling(current_node, env);
347
if(current_node != NULL)
349
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
350
qname = axiom_element_get_qname(current_element, env, current_node);
354
is_early_node_valid = AXIS2_FALSE;
356
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
360
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
362
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
364
is_early_node_valid = AXIS2_TRUE;
368
text_value = axiom_element_get_text(current_element, env, current_node);
369
if(text_value != NULL)
371
status = adb_configureNetworkType_set_userId(_configureNetworkType, env,
378
* axis2_qname_t *qname = NULL;
379
* axiom_attribute_t *the_attri = NULL;
381
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
382
* the_attri = axiom_element_get_attribute(current_element, env, qname);
384
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
386
axiom_attribute_t *the_attri = NULL;
387
axis2_char_t *attrib_text = NULL;
388
axutil_hash_t *attribute_hash = NULL;
390
attribute_hash = axiom_element_get_all_attributes(current_element, env);
395
axutil_hash_index_t *hi;
399
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
401
axutil_hash_this(hi, &key, NULL, &val);
403
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
405
the_attri = (axiom_attribute_t*)val;
413
attrib_text = axiom_attribute_get_value(the_attri, env);
417
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
418
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
421
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
423
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
424
status = AXIS2_FAILURE;
428
/* after all, we found this is a empty string */
429
status = adb_configureNetworkType_set_userId(_configureNetworkType, env,
434
if(AXIS2_FAILURE == status)
436
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
439
axutil_qname_free(element_qname, env);
441
return AXIS2_FAILURE;
447
axutil_qname_free(element_qname, env);
448
element_qname = NULL;
454
* building statusMessage element
460
* because elements are ordered this works fine
464
if(current_node != NULL && is_early_node_valid)
466
current_node = axiom_node_get_next_sibling(current_node, env);
469
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
471
current_node = axiom_node_get_next_sibling(current_node, env);
473
if(current_node != NULL)
475
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
476
qname = axiom_element_get_qname(current_element, env, current_node);
480
is_early_node_valid = AXIS2_FALSE;
482
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
486
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
488
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
490
is_early_node_valid = AXIS2_TRUE;
494
text_value = axiom_element_get_text(current_element, env, current_node);
495
if(text_value != NULL)
497
status = adb_configureNetworkType_set_statusMessage(_configureNetworkType, env,
501
if(AXIS2_FAILURE == status)
503
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
506
axutil_qname_free(element_qname, env);
508
return AXIS2_FAILURE;
514
axutil_qname_free(element_qname, env);
515
element_qname = NULL;
521
* building return element
527
* because elements are ordered this works fine
531
if(current_node != NULL && is_early_node_valid)
533
current_node = axiom_node_get_next_sibling(current_node, env);
536
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
538
current_node = axiom_node_get_next_sibling(current_node, env);
540
if(current_node != NULL)
542
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
543
qname = axiom_element_get_qname(current_element, env, current_node);
547
is_early_node_valid = AXIS2_FALSE;
549
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
553
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
555
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
557
is_early_node_valid = AXIS2_TRUE;
561
text_value = axiom_element_get_text(current_element, env, current_node);
562
if(text_value != NULL)
564
if (!axutil_strcasecmp(text_value , "true"))
566
status = adb_configureNetworkType_set_return(_configureNetworkType, env,
571
status = adb_configureNetworkType_set_return(_configureNetworkType, env,
578
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
579
status = AXIS2_FAILURE;
582
if(AXIS2_FAILURE == status)
584
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
587
axutil_qname_free(element_qname, env);
589
return AXIS2_FAILURE;
595
axutil_qname_free(element_qname, env);
596
element_qname = NULL;
600
* building rules array
602
arr_list = axutil_array_list_create(env, 10);
607
* building rules element
612
element_qname = axutil_qname_create(env, "rules", "http://eucalyptus.ucsb.edu/", NULL);
615
for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
618
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
620
current_node =axiom_node_get_next_sibling(current_node, env);
621
is_early_node_valid = AXIS2_FALSE;
625
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
626
qname = axiom_element_get_qname(current_element, env, current_node);
628
if (axutil_qname_equals(element_qname, env, qname))
631
is_early_node_valid = AXIS2_TRUE;
634
element = (void*)adb_networkRule_create(env);
636
status = adb_networkRule_deserialize((adb_networkRule_t*)element, env,
637
¤t_node, &is_early_node_valid, AXIS2_FALSE);
639
if(AXIS2_FAILURE == status)
641
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element rules ");
645
axutil_array_list_add_at(arr_list, env, i, element);
648
if(AXIS2_FAILURE == status)
650
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for rules ");
653
axutil_qname_free(element_qname, env);
657
axutil_array_list_free(arr_list, env);
659
return AXIS2_FAILURE;
663
current_node = axiom_node_get_next_sibling(current_node, env);
667
is_early_node_valid = AXIS2_FALSE;
676
/* found element out of order */
677
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "rules (@minOccurs = '0') only have %d elements", i);
680
axutil_qname_free(element_qname, env);
684
axutil_array_list_free(arr_list, env);
686
return AXIS2_FAILURE;
690
if(0 == axutil_array_list_size(arr_list,env))
692
axutil_array_list_free(arr_list, env);
696
status = adb_configureNetworkType_set_rules(_configureNetworkType, env,
703
axutil_qname_free(element_qname, env);
704
element_qname = NULL;
710
axis2_bool_t AXIS2_CALL
711
adb_configureNetworkType_is_particle()
720
adb_configureNetworkType_declare_parent_namespaces(
721
adb_configureNetworkType_t* _configureNetworkType,
722
const axutil_env_t *env, axiom_element_t *parent_element,
723
axutil_hash_t *namespaces, int *next_ns_index)
726
/* Here this is an empty function, Nothing to declare */
732
axiom_node_t* AXIS2_CALL
733
adb_configureNetworkType_serialize(
734
adb_configureNetworkType_t* _configureNetworkType,
735
const axutil_env_t *env, axiom_node_t *parent, axiom_element_t *parent_element, int parent_tag_closed, axutil_hash_t *namespaces, int *next_ns_index)
739
axis2_char_t *string_to_stream;
742
axiom_node_t *current_node = NULL;
747
axiom_namespace_t *ns1 = NULL;
749
axis2_char_t *qname_uri = NULL;
750
axis2_char_t *qname_prefix = NULL;
751
axis2_char_t *p_prefix = NULL;
752
axis2_bool_t ns_already_defined;
756
void *element = NULL;
758
axis2_char_t *text_value_1;
759
axis2_char_t *text_value_1_temp;
761
axis2_char_t *text_value_2;
762
axis2_char_t *text_value_2_temp;
764
axis2_char_t *text_value_3;
765
axis2_char_t *text_value_3_temp;
767
axis2_char_t text_value_4[64];
769
axis2_char_t text_value_5[64];
771
axis2_char_t *start_input_str = NULL;
772
axis2_char_t *end_input_str = NULL;
773
unsigned int start_input_str_len = 0;
774
unsigned int end_input_str_len = 0;
777
axiom_data_source_t *data_source = NULL;
778
axutil_stream_t *stream = NULL;
782
AXIS2_ENV_CHECK(env, NULL);
783
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, NULL);
786
current_node = parent;
787
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
790
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
794
if(!parent_tag_closed)
797
string_to_stream = ">";
798
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
803
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
805
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
806
sprintf(p_prefix, "n%d", (*next_ns_index)++);
807
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
809
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
810
"http://eucalyptus.ucsb.edu/",
815
if (!_configureNetworkType->is_valid_correlationId)
818
/* no need to complain for minoccurs=0 element */
824
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
825
(4 + axutil_strlen(p_prefix) +
826
axutil_strlen("correlationId")));
828
/* axutil_strlen("<:>") + 1 = 4 */
829
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
830
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
831
/* axutil_strlen("</:>") + 1 = 5 */
839
* parsing correlationId element
844
sprintf(start_input_str, "<%s%scorrelationId>",
845
p_prefix?p_prefix:"",
846
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
848
start_input_str_len = axutil_strlen(start_input_str);
849
sprintf(end_input_str, "</%s%scorrelationId>",
850
p_prefix?p_prefix:"",
851
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
852
end_input_str_len = axutil_strlen(end_input_str);
854
text_value_1 = _configureNetworkType->property_correlationId;
856
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
859
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
860
if (text_value_1_temp)
862
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
863
AXIS2_FREE(env->allocator, text_value_1_temp);
867
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
870
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
873
AXIS2_FREE(env->allocator,start_input_str);
874
AXIS2_FREE(env->allocator,end_input_str);
878
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
880
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
881
sprintf(p_prefix, "n%d", (*next_ns_index)++);
882
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
884
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
885
"http://eucalyptus.ucsb.edu/",
890
if (!_configureNetworkType->is_valid_userId)
893
/* no need to complain for minoccurs=0 element */
899
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
900
(4 + axutil_strlen(p_prefix) +
901
axutil_strlen("userId")));
903
/* axutil_strlen("<:>") + 1 = 4 */
904
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
905
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
906
/* axutil_strlen("</:>") + 1 = 5 */
914
* parsing userId element
919
sprintf(start_input_str, "<%s%suserId>",
920
p_prefix?p_prefix:"",
921
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
923
start_input_str_len = axutil_strlen(start_input_str);
924
sprintf(end_input_str, "</%s%suserId>",
925
p_prefix?p_prefix:"",
926
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
927
end_input_str_len = axutil_strlen(end_input_str);
929
text_value_2 = _configureNetworkType->property_userId;
931
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
934
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
935
if (text_value_2_temp)
937
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
938
AXIS2_FREE(env->allocator, text_value_2_temp);
942
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
945
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
948
AXIS2_FREE(env->allocator,start_input_str);
949
AXIS2_FREE(env->allocator,end_input_str);
953
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
955
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
956
sprintf(p_prefix, "n%d", (*next_ns_index)++);
957
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
959
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
960
"http://eucalyptus.ucsb.edu/",
965
if (!_configureNetworkType->is_valid_statusMessage)
968
/* no need to complain for minoccurs=0 element */
974
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
975
(4 + axutil_strlen(p_prefix) +
976
axutil_strlen("statusMessage")));
978
/* axutil_strlen("<:>") + 1 = 4 */
979
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
980
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
981
/* axutil_strlen("</:>") + 1 = 5 */
989
* parsing statusMessage element
994
sprintf(start_input_str, "<%s%sstatusMessage>",
995
p_prefix?p_prefix:"",
996
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
998
start_input_str_len = axutil_strlen(start_input_str);
999
sprintf(end_input_str, "</%s%sstatusMessage>",
1000
p_prefix?p_prefix:"",
1001
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1002
end_input_str_len = axutil_strlen(end_input_str);
1004
text_value_3 = _configureNetworkType->property_statusMessage;
1006
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1009
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1010
if (text_value_3_temp)
1012
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1013
AXIS2_FREE(env->allocator, text_value_3_temp);
1017
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1020
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1023
AXIS2_FREE(env->allocator,start_input_str);
1024
AXIS2_FREE(env->allocator,end_input_str);
1028
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1030
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1031
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1032
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1034
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1035
"http://eucalyptus.ucsb.edu/",
1040
if (!_configureNetworkType->is_valid_return)
1043
/* no need to complain for minoccurs=0 element */
1049
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1050
(4 + axutil_strlen(p_prefix) +
1051
axutil_strlen("return")));
1053
/* axutil_strlen("<:>") + 1 = 4 */
1054
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1055
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1056
/* axutil_strlen("</:>") + 1 = 5 */
1064
* parsing return element
1069
sprintf(start_input_str, "<%s%sreturn>",
1070
p_prefix?p_prefix:"",
1071
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1073
start_input_str_len = axutil_strlen(start_input_str);
1074
sprintf(end_input_str, "</%s%sreturn>",
1075
p_prefix?p_prefix:"",
1076
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1077
end_input_str_len = axutil_strlen(end_input_str);
1079
strcpy(text_value_4, (_configureNetworkType->property_return)?"true":"false");
1081
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1083
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1085
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1088
AXIS2_FREE(env->allocator,start_input_str);
1089
AXIS2_FREE(env->allocator,end_input_str);
1093
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1095
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1096
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1097
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1099
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1100
"http://eucalyptus.ucsb.edu/",
1105
if (!_configureNetworkType->is_valid_rules)
1108
/* no need to complain for minoccurs=0 element */
1114
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1115
(4 + axutil_strlen(p_prefix) +
1116
axutil_strlen("rules")));
1118
/* axutil_strlen("<:>") + 1 = 4 */
1119
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1120
(5 + axutil_strlen(p_prefix) + axutil_strlen("rules")));
1121
/* axutil_strlen("</:>") + 1 = 5 */
1128
* Parsing rules array
1130
if (_configureNetworkType->property_rules != NULL)
1134
sprintf(start_input_str, "<%s%srules",
1135
p_prefix?p_prefix:"",
1136
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1138
start_input_str_len = axutil_strlen(start_input_str);
1140
sprintf(end_input_str, "</%s%srules>",
1141
p_prefix?p_prefix:"",
1142
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1143
end_input_str_len = axutil_strlen(end_input_str);
1145
count = axutil_array_list_size(_configureNetworkType->property_rules, env);
1146
for(i = 0; i < count; i ++)
1148
element = axutil_array_list_get(_configureNetworkType->property_rules, env, i);
1157
* parsing rules element
1162
if(!adb_networkRule_is_particle())
1164
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1167
adb_networkRule_serialize((adb_networkRule_t*)element,
1168
env, current_node, parent_element,
1169
adb_networkRule_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
1171
if(!adb_networkRule_is_particle())
1173
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1180
AXIS2_FREE(env->allocator,start_input_str);
1181
AXIS2_FREE(env->allocator,end_input_str);
1193
* getter for correlationId.
1195
axis2_char_t* AXIS2_CALL
1196
adb_configureNetworkType_get_correlationId(
1197
adb_configureNetworkType_t* _configureNetworkType,
1198
const axutil_env_t *env)
1201
AXIS2_ENV_CHECK(env, NULL);
1202
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, NULL);
1205
return _configureNetworkType->property_correlationId;
1209
* setter for correlationId
1211
axis2_status_t AXIS2_CALL
1212
adb_configureNetworkType_set_correlationId(
1213
adb_configureNetworkType_t* _configureNetworkType,
1214
const axutil_env_t *env,
1215
const axis2_char_t* arg_correlationId)
1219
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1220
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1222
if(_configureNetworkType->is_valid_correlationId &&
1223
arg_correlationId == _configureNetworkType->property_correlationId)
1226
return AXIS2_SUCCESS;
1229
adb_configureNetworkType_reset_correlationId(_configureNetworkType, env);
1232
if(NULL == arg_correlationId)
1234
/* We are already done */
1235
return AXIS2_SUCCESS;
1237
_configureNetworkType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1238
if(NULL == _configureNetworkType->property_correlationId)
1240
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1241
return AXIS2_FAILURE;
1243
_configureNetworkType->is_valid_correlationId = AXIS2_TRUE;
1245
return AXIS2_SUCCESS;
1251
* resetter for correlationId
1253
axis2_status_t AXIS2_CALL
1254
adb_configureNetworkType_reset_correlationId(
1255
adb_configureNetworkType_t* _configureNetworkType,
1256
const axutil_env_t *env)
1260
void *element = NULL;
1262
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1263
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1269
if(_configureNetworkType->property_correlationId != NULL)
1273
AXIS2_FREE(env-> allocator, _configureNetworkType->property_correlationId);
1274
_configureNetworkType->property_correlationId = NULL;
1279
_configureNetworkType->is_valid_correlationId = AXIS2_FALSE;
1280
return AXIS2_SUCCESS;
1284
* Check whether correlationId is nill
1286
axis2_bool_t AXIS2_CALL
1287
adb_configureNetworkType_is_correlationId_nil(
1288
adb_configureNetworkType_t* _configureNetworkType,
1289
const axutil_env_t *env)
1291
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1292
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_TRUE);
1294
return !_configureNetworkType->is_valid_correlationId;
1298
* Set correlationId to nill (currently the same as reset)
1300
axis2_status_t AXIS2_CALL
1301
adb_configureNetworkType_set_correlationId_nil(
1302
adb_configureNetworkType_t* _configureNetworkType,
1303
const axutil_env_t *env)
1305
return adb_configureNetworkType_reset_correlationId(_configureNetworkType, env);
1311
* getter for userId.
1313
axis2_char_t* AXIS2_CALL
1314
adb_configureNetworkType_get_userId(
1315
adb_configureNetworkType_t* _configureNetworkType,
1316
const axutil_env_t *env)
1319
AXIS2_ENV_CHECK(env, NULL);
1320
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, NULL);
1323
return _configureNetworkType->property_userId;
1329
axis2_status_t AXIS2_CALL
1330
adb_configureNetworkType_set_userId(
1331
adb_configureNetworkType_t* _configureNetworkType,
1332
const axutil_env_t *env,
1333
const axis2_char_t* arg_userId)
1337
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1338
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1340
if(_configureNetworkType->is_valid_userId &&
1341
arg_userId == _configureNetworkType->property_userId)
1344
return AXIS2_SUCCESS;
1347
adb_configureNetworkType_reset_userId(_configureNetworkType, env);
1350
if(NULL == arg_userId)
1352
/* We are already done */
1353
return AXIS2_SUCCESS;
1355
_configureNetworkType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1356
if(NULL == _configureNetworkType->property_userId)
1358
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1359
return AXIS2_FAILURE;
1361
_configureNetworkType->is_valid_userId = AXIS2_TRUE;
1363
return AXIS2_SUCCESS;
1369
* resetter for userId
1371
axis2_status_t AXIS2_CALL
1372
adb_configureNetworkType_reset_userId(
1373
adb_configureNetworkType_t* _configureNetworkType,
1374
const axutil_env_t *env)
1378
void *element = NULL;
1380
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1381
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1387
if(_configureNetworkType->property_userId != NULL)
1391
AXIS2_FREE(env-> allocator, _configureNetworkType->property_userId);
1392
_configureNetworkType->property_userId = NULL;
1397
_configureNetworkType->is_valid_userId = AXIS2_FALSE;
1398
return AXIS2_SUCCESS;
1402
* Check whether userId is nill
1404
axis2_bool_t AXIS2_CALL
1405
adb_configureNetworkType_is_userId_nil(
1406
adb_configureNetworkType_t* _configureNetworkType,
1407
const axutil_env_t *env)
1409
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1410
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_TRUE);
1412
return !_configureNetworkType->is_valid_userId;
1416
* Set userId to nill (currently the same as reset)
1418
axis2_status_t AXIS2_CALL
1419
adb_configureNetworkType_set_userId_nil(
1420
adb_configureNetworkType_t* _configureNetworkType,
1421
const axutil_env_t *env)
1423
return adb_configureNetworkType_reset_userId(_configureNetworkType, env);
1429
* getter for statusMessage.
1431
axis2_char_t* AXIS2_CALL
1432
adb_configureNetworkType_get_statusMessage(
1433
adb_configureNetworkType_t* _configureNetworkType,
1434
const axutil_env_t *env)
1437
AXIS2_ENV_CHECK(env, NULL);
1438
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, NULL);
1441
return _configureNetworkType->property_statusMessage;
1445
* setter for statusMessage
1447
axis2_status_t AXIS2_CALL
1448
adb_configureNetworkType_set_statusMessage(
1449
adb_configureNetworkType_t* _configureNetworkType,
1450
const axutil_env_t *env,
1451
const axis2_char_t* arg_statusMessage)
1455
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1456
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1458
if(_configureNetworkType->is_valid_statusMessage &&
1459
arg_statusMessage == _configureNetworkType->property_statusMessage)
1462
return AXIS2_SUCCESS;
1465
adb_configureNetworkType_reset_statusMessage(_configureNetworkType, env);
1468
if(NULL == arg_statusMessage)
1470
/* We are already done */
1471
return AXIS2_SUCCESS;
1473
_configureNetworkType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1474
if(NULL == _configureNetworkType->property_statusMessage)
1476
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1477
return AXIS2_FAILURE;
1479
_configureNetworkType->is_valid_statusMessage = AXIS2_TRUE;
1481
return AXIS2_SUCCESS;
1487
* resetter for statusMessage
1489
axis2_status_t AXIS2_CALL
1490
adb_configureNetworkType_reset_statusMessage(
1491
adb_configureNetworkType_t* _configureNetworkType,
1492
const axutil_env_t *env)
1496
void *element = NULL;
1498
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1499
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1505
if(_configureNetworkType->property_statusMessage != NULL)
1509
AXIS2_FREE(env-> allocator, _configureNetworkType->property_statusMessage);
1510
_configureNetworkType->property_statusMessage = NULL;
1515
_configureNetworkType->is_valid_statusMessage = AXIS2_FALSE;
1516
return AXIS2_SUCCESS;
1520
* Check whether statusMessage is nill
1522
axis2_bool_t AXIS2_CALL
1523
adb_configureNetworkType_is_statusMessage_nil(
1524
adb_configureNetworkType_t* _configureNetworkType,
1525
const axutil_env_t *env)
1527
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1528
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_TRUE);
1530
return !_configureNetworkType->is_valid_statusMessage;
1534
* Set statusMessage to nill (currently the same as reset)
1536
axis2_status_t AXIS2_CALL
1537
adb_configureNetworkType_set_statusMessage_nil(
1538
adb_configureNetworkType_t* _configureNetworkType,
1539
const axutil_env_t *env)
1541
return adb_configureNetworkType_reset_statusMessage(_configureNetworkType, env);
1547
* getter for return.
1549
axis2_bool_t AXIS2_CALL
1550
adb_configureNetworkType_get_return(
1551
adb_configureNetworkType_t* _configureNetworkType,
1552
const axutil_env_t *env)
1555
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1556
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, (axis2_bool_t)0);
1559
return _configureNetworkType->property_return;
1565
axis2_status_t AXIS2_CALL
1566
adb_configureNetworkType_set_return(
1567
adb_configureNetworkType_t* _configureNetworkType,
1568
const axutil_env_t *env,
1569
axis2_bool_t arg_return)
1573
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1574
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1576
if(_configureNetworkType->is_valid_return &&
1577
arg_return == _configureNetworkType->property_return)
1580
return AXIS2_SUCCESS;
1583
adb_configureNetworkType_reset_return(_configureNetworkType, env);
1585
_configureNetworkType->property_return = arg_return;
1586
_configureNetworkType->is_valid_return = AXIS2_TRUE;
1588
return AXIS2_SUCCESS;
1594
* resetter for return
1596
axis2_status_t AXIS2_CALL
1597
adb_configureNetworkType_reset_return(
1598
adb_configureNetworkType_t* _configureNetworkType,
1599
const axutil_env_t *env)
1603
void *element = NULL;
1605
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1606
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1609
_configureNetworkType->is_valid_return = AXIS2_FALSE;
1610
return AXIS2_SUCCESS;
1614
* Check whether return is nill
1616
axis2_bool_t AXIS2_CALL
1617
adb_configureNetworkType_is_return_nil(
1618
adb_configureNetworkType_t* _configureNetworkType,
1619
const axutil_env_t *env)
1621
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1622
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_TRUE);
1624
return !_configureNetworkType->is_valid_return;
1628
* Set return to nill (currently the same as reset)
1630
axis2_status_t AXIS2_CALL
1631
adb_configureNetworkType_set_return_nil(
1632
adb_configureNetworkType_t* _configureNetworkType,
1633
const axutil_env_t *env)
1635
return adb_configureNetworkType_reset_return(_configureNetworkType, env);
1643
axutil_array_list_t* AXIS2_CALL
1644
adb_configureNetworkType_get_rules(
1645
adb_configureNetworkType_t* _configureNetworkType,
1646
const axutil_env_t *env)
1649
AXIS2_ENV_CHECK(env, NULL);
1650
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, NULL);
1653
return _configureNetworkType->property_rules;
1659
axis2_status_t AXIS2_CALL
1660
adb_configureNetworkType_set_rules(
1661
adb_configureNetworkType_t* _configureNetworkType,
1662
const axutil_env_t *env,
1663
axutil_array_list_t* arg_rules)
1668
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1671
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1672
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1674
if(_configureNetworkType->is_valid_rules &&
1675
arg_rules == _configureNetworkType->property_rules)
1678
return AXIS2_SUCCESS;
1682
size = axutil_array_list_size(arg_rules, env);
1686
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "rules has less than minOccurs(0)");
1687
return AXIS2_FAILURE;
1689
for(i = 0; i < size; i ++ )
1691
if(NULL != axutil_array_list_get(arg_rules, env, i))
1693
non_nil_exists = AXIS2_TRUE;
1698
adb_configureNetworkType_reset_rules(_configureNetworkType, env);
1701
if(NULL == arg_rules)
1703
/* We are already done */
1704
return AXIS2_SUCCESS;
1706
_configureNetworkType->property_rules = arg_rules;
1709
_configureNetworkType->is_valid_rules = AXIS2_TRUE;
1713
return AXIS2_SUCCESS;
1718
* Get ith element of rules.
1720
adb_networkRule_t* AXIS2_CALL
1721
adb_configureNetworkType_get_rules_at(
1722
adb_configureNetworkType_t* _configureNetworkType,
1723
const axutil_env_t *env, int i)
1725
adb_networkRule_t* ret_val;
1728
AXIS2_ENV_CHECK(env, NULL);
1729
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, NULL);
1732
if(_configureNetworkType->property_rules == NULL)
1734
return (adb_networkRule_t*)0;
1736
ret_val = (adb_networkRule_t*)axutil_array_list_get(_configureNetworkType->property_rules, env, i);
1743
* Set the ith element of rules.
1745
axis2_status_t AXIS2_CALL
1746
adb_configureNetworkType_set_rules_at(
1747
adb_configureNetworkType_t* _configureNetworkType,
1748
const axutil_env_t *env, int i,
1749
adb_networkRule_t* arg_rules)
1751
void *element = NULL;
1755
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1759
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1760
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1762
if( _configureNetworkType->is_valid_rules &&
1763
_configureNetworkType->property_rules &&
1765
arg_rules == (adb_networkRule_t*)axutil_array_list_get(_configureNetworkType->property_rules, env, i))
1769
return AXIS2_SUCCESS;
1773
if(NULL == arg_rules)
1775
if(_configureNetworkType->property_rules != NULL)
1777
size = axutil_array_list_size(_configureNetworkType->property_rules, env);
1778
for(j = 0, k = 0; j < size; j ++ )
1780
if(i == j) continue;
1781
if(NULL != axutil_array_list_get(_configureNetworkType->property_rules, env, i))
1784
non_nil_exists = AXIS2_TRUE;
1795
non_nil_exists = AXIS2_TRUE;
1800
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of rules is beinng set to be smaller than the specificed number of minOccurs(0)");
1801
return AXIS2_FAILURE;
1804
if(_configureNetworkType->property_rules == NULL)
1806
_configureNetworkType->property_rules = axutil_array_list_create(env, 10);
1809
/* check whether there already exist an element */
1810
element = axutil_array_list_get(_configureNetworkType->property_rules, env, i);
1816
adb_networkRule_free((adb_networkRule_t*)element, env);
1824
_configureNetworkType->is_valid_rules = AXIS2_FALSE;
1825
axutil_array_list_set(_configureNetworkType->property_rules , env, i, NULL);
1827
return AXIS2_SUCCESS;
1830
axutil_array_list_set(_configureNetworkType->property_rules , env, i, arg_rules);
1831
_configureNetworkType->is_valid_rules = AXIS2_TRUE;
1833
return AXIS2_SUCCESS;
1839
axis2_status_t AXIS2_CALL
1840
adb_configureNetworkType_add_rules(
1841
adb_configureNetworkType_t* _configureNetworkType,
1842
const axutil_env_t *env,
1843
adb_networkRule_t* arg_rules)
1847
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1848
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1851
if(NULL == arg_rules)
1854
return AXIS2_SUCCESS;
1859
if(_configureNetworkType->property_rules == NULL)
1861
_configureNetworkType->property_rules = axutil_array_list_create(env, 10);
1863
if(_configureNetworkType->property_rules == NULL)
1865
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for rules");
1866
return AXIS2_FAILURE;
1870
axutil_array_list_add(_configureNetworkType->property_rules , env, arg_rules);
1871
_configureNetworkType->is_valid_rules = AXIS2_TRUE;
1872
return AXIS2_SUCCESS;
1876
* Get the size of the rules array.
1879
adb_configureNetworkType_sizeof_rules(
1880
adb_configureNetworkType_t* _configureNetworkType,
1881
const axutil_env_t *env)
1883
AXIS2_ENV_CHECK(env, -1);
1884
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, -1);
1885
if(_configureNetworkType->property_rules == NULL)
1889
return axutil_array_list_size(_configureNetworkType->property_rules, env);
1893
* remove the ith element, same as set_nil_at.
1895
axis2_status_t AXIS2_CALL
1896
adb_configureNetworkType_remove_rules_at(
1897
adb_configureNetworkType_t* _configureNetworkType,
1898
const axutil_env_t *env, int i)
1900
return adb_configureNetworkType_set_rules_nil_at(_configureNetworkType, env, i);
1906
* resetter for rules
1908
axis2_status_t AXIS2_CALL
1909
adb_configureNetworkType_reset_rules(
1910
adb_configureNetworkType_t* _configureNetworkType,
1911
const axutil_env_t *env)
1915
void *element = NULL;
1917
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1918
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
1922
if (_configureNetworkType->property_rules != NULL)
1924
count = axutil_array_list_size(_configureNetworkType->property_rules, env);
1925
for(i = 0; i < count; i ++)
1927
element = axutil_array_list_get(_configureNetworkType->property_rules, env, i);
1935
adb_networkRule_free((adb_networkRule_t*)element, env);
1943
axutil_array_list_free(_configureNetworkType->property_rules, env);
1945
_configureNetworkType->is_valid_rules = AXIS2_FALSE;
1946
return AXIS2_SUCCESS;
1950
* Check whether rules is nill
1952
axis2_bool_t AXIS2_CALL
1953
adb_configureNetworkType_is_rules_nil(
1954
adb_configureNetworkType_t* _configureNetworkType,
1955
const axutil_env_t *env)
1957
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1958
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_TRUE);
1960
return !_configureNetworkType->is_valid_rules;
1964
* Set rules to nill (currently the same as reset)
1966
axis2_status_t AXIS2_CALL
1967
adb_configureNetworkType_set_rules_nil(
1968
adb_configureNetworkType_t* _configureNetworkType,
1969
const axutil_env_t *env)
1971
return adb_configureNetworkType_reset_rules(_configureNetworkType, env);
1976
* Check whether rules is nill at i
1978
axis2_bool_t AXIS2_CALL
1979
adb_configureNetworkType_is_rules_nil_at(
1980
adb_configureNetworkType_t* _configureNetworkType,
1981
const axutil_env_t *env, int i)
1983
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1984
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_TRUE);
1986
return (_configureNetworkType->is_valid_rules == AXIS2_FALSE ||
1987
NULL == _configureNetworkType->property_rules ||
1988
NULL == axutil_array_list_get(_configureNetworkType->property_rules, env, i));
1992
* Set rules to nill at i
1994
axis2_status_t AXIS2_CALL
1995
adb_configureNetworkType_set_rules_nil_at(
1996
adb_configureNetworkType_t* _configureNetworkType,
1997
const axutil_env_t *env, int i)
1999
void *element = NULL;
2002
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2006
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2007
AXIS2_PARAM_CHECK(env->error, _configureNetworkType, AXIS2_FAILURE);
2009
if(_configureNetworkType->property_rules == NULL ||
2010
_configureNetworkType->is_valid_rules == AXIS2_FALSE)
2013
non_nil_exists = AXIS2_FALSE;
2017
size = axutil_array_list_size(_configureNetworkType->property_rules, env);
2018
for(j = 0, k = 0; j < size; j ++ )
2020
if(i == j) continue;
2021
if(NULL != axutil_array_list_get(_configureNetworkType->property_rules, env, i))
2024
non_nil_exists = AXIS2_TRUE;
2036
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of rules is beinng set to be smaller than the specificed number of minOccurs(0)");
2037
return AXIS2_FAILURE;
2040
if(_configureNetworkType->property_rules == NULL)
2042
_configureNetworkType->is_valid_rules = AXIS2_FALSE;
2044
return AXIS2_SUCCESS;
2047
/* check whether there already exist an element */
2048
element = axutil_array_list_get(_configureNetworkType->property_rules, env, i);
2054
adb_networkRule_free((adb_networkRule_t*)element, env);
2062
_configureNetworkType->is_valid_rules = AXIS2_FALSE;
2063
axutil_array_list_set(_configureNetworkType->property_rules , env, i, NULL);
2064
return AXIS2_SUCCESS;
2069
axutil_array_list_set(_configureNetworkType->property_rules , env, i, NULL);
2071
return AXIS2_SUCCESS;
added
removed
cluster/generated/adb_configureNetworkType.c
