4
* adb_describeNetworksType.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_describeNetworksType.h"
13
* This type was generated from the piece of schema that had
14
* name = describeNetworksType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_describeNetworksType
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
axis2_char_t* property_nameserver;
50
axis2_bool_t is_valid_nameserver;
53
axutil_array_list_t* property_clusterControllers;
56
axis2_bool_t is_valid_clusterControllers;
63
/************************* Private Function prototypes ********************************/
66
axis2_status_t AXIS2_CALL
67
adb_describeNetworksType_set_correlationId_nil(
68
adb_describeNetworksType_t* _describeNetworksType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_describeNetworksType_set_userId_nil(
74
adb_describeNetworksType_t* _describeNetworksType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_describeNetworksType_set_return_nil(
80
adb_describeNetworksType_t* _describeNetworksType,
81
const axutil_env_t *env);
84
axis2_status_t AXIS2_CALL
85
adb_describeNetworksType_set_nameserver_nil(
86
adb_describeNetworksType_t* _describeNetworksType,
87
const axutil_env_t *env);
89
axis2_status_t AXIS2_CALL
90
adb_describeNetworksType_set_clusterControllers_nil_at(
91
adb_describeNetworksType_t* _describeNetworksType,
92
const axutil_env_t *env, int i);
95
axis2_status_t AXIS2_CALL
96
adb_describeNetworksType_set_clusterControllers_nil(
97
adb_describeNetworksType_t* _describeNetworksType,
98
const axutil_env_t *env);
102
/************************* Function Implmentations ********************************/
103
adb_describeNetworksType_t* AXIS2_CALL
104
adb_describeNetworksType_create(
105
const axutil_env_t *env)
107
adb_describeNetworksType_t *_describeNetworksType = NULL;
109
AXIS2_ENV_CHECK(env, NULL);
111
_describeNetworksType = (adb_describeNetworksType_t *) AXIS2_MALLOC(env->
112
allocator, sizeof(adb_describeNetworksType_t));
114
if(NULL == _describeNetworksType)
116
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
120
memset(_describeNetworksType, 0, sizeof(adb_describeNetworksType_t));
122
_describeNetworksType->property_correlationId = NULL;
123
_describeNetworksType->is_valid_correlationId = AXIS2_FALSE;
124
_describeNetworksType->property_userId = NULL;
125
_describeNetworksType->is_valid_userId = AXIS2_FALSE;
126
_describeNetworksType->property_statusMessage = NULL;
127
_describeNetworksType->is_valid_statusMessage = AXIS2_FALSE;
128
_describeNetworksType->is_valid_return = AXIS2_FALSE;
129
_describeNetworksType->property_nameserver = NULL;
130
_describeNetworksType->is_valid_nameserver = AXIS2_FALSE;
131
_describeNetworksType->property_clusterControllers = NULL;
132
_describeNetworksType->is_valid_clusterControllers = AXIS2_FALSE;
135
return _describeNetworksType;
138
axis2_status_t AXIS2_CALL
139
adb_describeNetworksType_free (
140
adb_describeNetworksType_t* _describeNetworksType,
141
const axutil_env_t *env)
146
void *element = NULL;
149
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
150
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
152
adb_describeNetworksType_reset_correlationId(_describeNetworksType, env);
153
adb_describeNetworksType_reset_userId(_describeNetworksType, env);
154
adb_describeNetworksType_reset_statusMessage(_describeNetworksType, env);
155
adb_describeNetworksType_reset_return(_describeNetworksType, env);
156
adb_describeNetworksType_reset_nameserver(_describeNetworksType, env);
157
adb_describeNetworksType_reset_clusterControllers(_describeNetworksType, env);
160
if(_describeNetworksType)
162
AXIS2_FREE(env->allocator, _describeNetworksType);
163
_describeNetworksType = NULL;
165
return AXIS2_SUCCESS;
171
axis2_status_t AXIS2_CALL
172
adb_describeNetworksType_deserialize(
173
adb_describeNetworksType_t* _describeNetworksType,
174
const axutil_env_t *env,
175
axiom_node_t **dp_parent,
176
axis2_bool_t *dp_is_early_node_valid,
177
axis2_bool_t dont_care_minoccurs)
179
axiom_node_t *parent = *dp_parent;
181
axis2_status_t status = AXIS2_SUCCESS;
183
void *element = NULL;
185
axis2_char_t* text_value = NULL;
186
axutil_qname_t *qname = NULL;
189
axutil_array_list_t *arr_list = NULL;
191
int sequence_broken = 0;
192
axiom_node_t *tmp_node = NULL;
194
axutil_qname_t *element_qname = NULL;
196
axiom_node_t *first_node = NULL;
197
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
198
axiom_node_t *current_node = NULL;
199
axiom_element_t *current_element = NULL;
201
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
202
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
206
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
208
parent = axiom_node_get_next_sibling(parent, env);
212
/* This should be checked before everything */
213
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
214
"Failed in building adb object for describeNetworksType : "
215
"NULL elemenet can not be passed to deserialize");
216
return AXIS2_FAILURE;
220
first_node = axiom_node_get_first_child(parent, env);
226
* building correlationId element
231
current_node = first_node;
232
is_early_node_valid = AXIS2_FALSE;
235
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
237
current_node = axiom_node_get_next_sibling(current_node, env);
239
if(current_node != NULL)
241
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
242
qname = axiom_element_get_qname(current_element, env, current_node);
245
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
249
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
251
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
253
is_early_node_valid = AXIS2_TRUE;
257
text_value = axiom_element_get_text(current_element, env, current_node);
258
if(text_value != NULL)
260
status = adb_describeNetworksType_set_correlationId(_describeNetworksType, env,
267
* axis2_qname_t *qname = NULL;
268
* axiom_attribute_t *the_attri = NULL;
270
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
271
* the_attri = axiom_element_get_attribute(current_element, env, qname);
273
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
275
axiom_attribute_t *the_attri = NULL;
276
axis2_char_t *attrib_text = NULL;
277
axutil_hash_t *attribute_hash = NULL;
279
attribute_hash = axiom_element_get_all_attributes(current_element, env);
284
axutil_hash_index_t *hi;
288
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
290
axutil_hash_this(hi, &key, NULL, &val);
292
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
294
the_attri = (axiom_attribute_t*)val;
302
attrib_text = axiom_attribute_get_value(the_attri, env);
306
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
307
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
310
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
312
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
313
status = AXIS2_FAILURE;
317
/* after all, we found this is a empty string */
318
status = adb_describeNetworksType_set_correlationId(_describeNetworksType, env,
323
if(AXIS2_FAILURE == status)
325
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
328
axutil_qname_free(element_qname, env);
330
return AXIS2_FAILURE;
336
axutil_qname_free(element_qname, env);
337
element_qname = NULL;
343
* building userId element
349
* because elements are ordered this works fine
353
if(current_node != NULL && is_early_node_valid)
355
current_node = axiom_node_get_next_sibling(current_node, env);
358
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
360
current_node = axiom_node_get_next_sibling(current_node, env);
362
if(current_node != NULL)
364
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
365
qname = axiom_element_get_qname(current_element, env, current_node);
369
is_early_node_valid = AXIS2_FALSE;
371
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
375
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
377
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
379
is_early_node_valid = AXIS2_TRUE;
383
text_value = axiom_element_get_text(current_element, env, current_node);
384
if(text_value != NULL)
386
status = adb_describeNetworksType_set_userId(_describeNetworksType, env,
393
* axis2_qname_t *qname = NULL;
394
* axiom_attribute_t *the_attri = NULL;
396
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
397
* the_attri = axiom_element_get_attribute(current_element, env, qname);
399
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
401
axiom_attribute_t *the_attri = NULL;
402
axis2_char_t *attrib_text = NULL;
403
axutil_hash_t *attribute_hash = NULL;
405
attribute_hash = axiom_element_get_all_attributes(current_element, env);
410
axutil_hash_index_t *hi;
414
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
416
axutil_hash_this(hi, &key, NULL, &val);
418
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
420
the_attri = (axiom_attribute_t*)val;
428
attrib_text = axiom_attribute_get_value(the_attri, env);
432
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
433
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
436
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
438
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
439
status = AXIS2_FAILURE;
443
/* after all, we found this is a empty string */
444
status = adb_describeNetworksType_set_userId(_describeNetworksType, env,
449
if(AXIS2_FAILURE == status)
451
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
454
axutil_qname_free(element_qname, env);
456
return AXIS2_FAILURE;
462
axutil_qname_free(element_qname, env);
463
element_qname = NULL;
469
* building statusMessage element
475
* because elements are ordered this works fine
479
if(current_node != NULL && is_early_node_valid)
481
current_node = axiom_node_get_next_sibling(current_node, env);
484
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
486
current_node = axiom_node_get_next_sibling(current_node, env);
488
if(current_node != NULL)
490
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
491
qname = axiom_element_get_qname(current_element, env, current_node);
495
is_early_node_valid = AXIS2_FALSE;
497
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
501
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
503
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
505
is_early_node_valid = AXIS2_TRUE;
509
text_value = axiom_element_get_text(current_element, env, current_node);
510
if(text_value != NULL)
512
status = adb_describeNetworksType_set_statusMessage(_describeNetworksType, env,
516
if(AXIS2_FAILURE == status)
518
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
521
axutil_qname_free(element_qname, env);
523
return AXIS2_FAILURE;
529
axutil_qname_free(element_qname, env);
530
element_qname = NULL;
536
* building return element
542
* because elements are ordered this works fine
546
if(current_node != NULL && is_early_node_valid)
548
current_node = axiom_node_get_next_sibling(current_node, env);
551
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
553
current_node = axiom_node_get_next_sibling(current_node, env);
555
if(current_node != NULL)
557
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
558
qname = axiom_element_get_qname(current_element, env, current_node);
562
is_early_node_valid = AXIS2_FALSE;
564
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
568
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
570
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
572
is_early_node_valid = AXIS2_TRUE;
576
text_value = axiom_element_get_text(current_element, env, current_node);
577
if(text_value != NULL)
579
if (!axutil_strcasecmp(text_value , "true"))
581
status = adb_describeNetworksType_set_return(_describeNetworksType, env,
586
status = adb_describeNetworksType_set_return(_describeNetworksType, env,
593
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
594
status = AXIS2_FAILURE;
597
if(AXIS2_FAILURE == status)
599
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
602
axutil_qname_free(element_qname, env);
604
return AXIS2_FAILURE;
610
axutil_qname_free(element_qname, env);
611
element_qname = NULL;
617
* building nameserver element
623
* because elements are ordered this works fine
627
if(current_node != NULL && is_early_node_valid)
629
current_node = axiom_node_get_next_sibling(current_node, env);
632
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
634
current_node = axiom_node_get_next_sibling(current_node, env);
636
if(current_node != NULL)
638
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
639
qname = axiom_element_get_qname(current_element, env, current_node);
643
is_early_node_valid = AXIS2_FALSE;
645
element_qname = axutil_qname_create(env, "nameserver", "http://eucalyptus.ucsb.edu/", NULL);
649
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
651
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
653
is_early_node_valid = AXIS2_TRUE;
657
text_value = axiom_element_get_text(current_element, env, current_node);
658
if(text_value != NULL)
660
status = adb_describeNetworksType_set_nameserver(_describeNetworksType, env,
667
* axis2_qname_t *qname = NULL;
668
* axiom_attribute_t *the_attri = NULL;
670
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
671
* the_attri = axiom_element_get_attribute(current_element, env, qname);
673
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
675
axiom_attribute_t *the_attri = NULL;
676
axis2_char_t *attrib_text = NULL;
677
axutil_hash_t *attribute_hash = NULL;
679
attribute_hash = axiom_element_get_all_attributes(current_element, env);
684
axutil_hash_index_t *hi;
688
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
690
axutil_hash_this(hi, &key, NULL, &val);
692
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
694
the_attri = (axiom_attribute_t*)val;
702
attrib_text = axiom_attribute_get_value(the_attri, env);
706
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
707
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
710
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
712
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element nameserver");
713
status = AXIS2_FAILURE;
717
/* after all, we found this is a empty string */
718
status = adb_describeNetworksType_set_nameserver(_describeNetworksType, env,
723
if(AXIS2_FAILURE == status)
725
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nameserver ");
728
axutil_qname_free(element_qname, env);
730
return AXIS2_FAILURE;
736
axutil_qname_free(element_qname, env);
737
element_qname = NULL;
741
* building clusterControllers array
743
arr_list = axutil_array_list_create(env, 10);
748
* building clusterControllers element
753
element_qname = axutil_qname_create(env, "clusterControllers", "http://eucalyptus.ucsb.edu/", NULL);
756
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;)
759
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
761
current_node =axiom_node_get_next_sibling(current_node, env);
762
is_early_node_valid = AXIS2_FALSE;
766
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
767
qname = axiom_element_get_qname(current_element, env, current_node);
769
if (axutil_qname_equals(element_qname, env, qname))
772
is_early_node_valid = AXIS2_TRUE;
775
text_value = axiom_element_get_text(current_element, env, current_node);
776
if(text_value != NULL)
778
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
784
* axis2_qname_t *qname = NULL;
785
* axiom_attribute_t *the_attri = NULL;
787
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
788
* the_attri = axiom_element_get_attribute(current_element, env, qname);
791
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
793
axiom_attribute_t *the_attri = NULL;
794
axis2_char_t *attrib_text = NULL;
795
axutil_hash_t *attribute_hash = NULL;
797
attribute_hash = axiom_element_get_all_attributes(current_element, env);
802
axutil_hash_index_t *hi;
806
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
808
axutil_hash_this(hi, &key, NULL, &val);
810
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
812
the_attri = (axiom_attribute_t*)val;
820
attrib_text = axiom_attribute_get_value(the_attri, env);
824
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
825
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
828
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
830
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element clusterControllers");
831
status = AXIS2_FAILURE;
835
/* after all, we found this is a empty string */
836
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
840
if(AXIS2_FAILURE == status)
842
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for clusterControllers ");
845
axutil_qname_free(element_qname, env);
849
axutil_array_list_free(arr_list, env);
851
return AXIS2_FAILURE;
855
current_node = axiom_node_get_next_sibling(current_node, env);
859
is_early_node_valid = AXIS2_FALSE;
868
/* found element out of order */
869
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "clusterControllers (@minOccurs = '0') only have %d elements", i);
872
axutil_qname_free(element_qname, env);
876
axutil_array_list_free(arr_list, env);
878
return AXIS2_FAILURE;
882
if(0 == axutil_array_list_size(arr_list,env))
884
axutil_array_list_free(arr_list, env);
888
status = adb_describeNetworksType_set_clusterControllers(_describeNetworksType, env,
895
axutil_qname_free(element_qname, env);
896
element_qname = NULL;
902
axis2_bool_t AXIS2_CALL
903
adb_describeNetworksType_is_particle()
912
adb_describeNetworksType_declare_parent_namespaces(
913
adb_describeNetworksType_t* _describeNetworksType,
914
const axutil_env_t *env, axiom_element_t *parent_element,
915
axutil_hash_t *namespaces, int *next_ns_index)
918
/* Here this is an empty function, Nothing to declare */
924
axiom_node_t* AXIS2_CALL
925
adb_describeNetworksType_serialize(
926
adb_describeNetworksType_t* _describeNetworksType,
927
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)
931
axis2_char_t *string_to_stream;
934
axiom_node_t *current_node = NULL;
939
axiom_namespace_t *ns1 = NULL;
941
axis2_char_t *qname_uri = NULL;
942
axis2_char_t *qname_prefix = NULL;
943
axis2_char_t *p_prefix = NULL;
944
axis2_bool_t ns_already_defined;
948
void *element = NULL;
950
axis2_char_t *text_value_1;
951
axis2_char_t *text_value_1_temp;
953
axis2_char_t *text_value_2;
954
axis2_char_t *text_value_2_temp;
956
axis2_char_t *text_value_3;
957
axis2_char_t *text_value_3_temp;
959
axis2_char_t text_value_4[64];
961
axis2_char_t *text_value_5;
962
axis2_char_t *text_value_5_temp;
964
axis2_char_t *text_value_6;
965
axis2_char_t *text_value_6_temp;
967
axis2_char_t *start_input_str = NULL;
968
axis2_char_t *end_input_str = NULL;
969
unsigned int start_input_str_len = 0;
970
unsigned int end_input_str_len = 0;
973
axiom_data_source_t *data_source = NULL;
974
axutil_stream_t *stream = NULL;
978
AXIS2_ENV_CHECK(env, NULL);
979
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, NULL);
982
current_node = parent;
983
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
986
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
990
if(!parent_tag_closed)
993
string_to_stream = ">";
994
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
999
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1001
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1002
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1003
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1005
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1006
"http://eucalyptus.ucsb.edu/",
1011
if (!_describeNetworksType->is_valid_correlationId)
1014
/* no need to complain for minoccurs=0 element */
1020
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1021
(4 + axutil_strlen(p_prefix) +
1022
axutil_strlen("correlationId")));
1024
/* axutil_strlen("<:>") + 1 = 4 */
1025
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1026
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1027
/* axutil_strlen("</:>") + 1 = 5 */
1035
* parsing correlationId element
1040
sprintf(start_input_str, "<%s%scorrelationId>",
1041
p_prefix?p_prefix:"",
1042
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1044
start_input_str_len = axutil_strlen(start_input_str);
1045
sprintf(end_input_str, "</%s%scorrelationId>",
1046
p_prefix?p_prefix:"",
1047
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1048
end_input_str_len = axutil_strlen(end_input_str);
1050
text_value_1 = _describeNetworksType->property_correlationId;
1052
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1055
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1056
if (text_value_1_temp)
1058
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1059
AXIS2_FREE(env->allocator, text_value_1_temp);
1063
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1066
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1069
AXIS2_FREE(env->allocator,start_input_str);
1070
AXIS2_FREE(env->allocator,end_input_str);
1074
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1076
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1077
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1078
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1080
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1081
"http://eucalyptus.ucsb.edu/",
1086
if (!_describeNetworksType->is_valid_userId)
1089
/* no need to complain for minoccurs=0 element */
1095
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1096
(4 + axutil_strlen(p_prefix) +
1097
axutil_strlen("userId")));
1099
/* axutil_strlen("<:>") + 1 = 4 */
1100
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1101
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1102
/* axutil_strlen("</:>") + 1 = 5 */
1110
* parsing userId element
1115
sprintf(start_input_str, "<%s%suserId>",
1116
p_prefix?p_prefix:"",
1117
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1119
start_input_str_len = axutil_strlen(start_input_str);
1120
sprintf(end_input_str, "</%s%suserId>",
1121
p_prefix?p_prefix:"",
1122
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1123
end_input_str_len = axutil_strlen(end_input_str);
1125
text_value_2 = _describeNetworksType->property_userId;
1127
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1130
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1131
if (text_value_2_temp)
1133
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1134
AXIS2_FREE(env->allocator, text_value_2_temp);
1138
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1141
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1144
AXIS2_FREE(env->allocator,start_input_str);
1145
AXIS2_FREE(env->allocator,end_input_str);
1149
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1151
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1152
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1153
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1155
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1156
"http://eucalyptus.ucsb.edu/",
1161
if (!_describeNetworksType->is_valid_statusMessage)
1164
/* no need to complain for minoccurs=0 element */
1170
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1171
(4 + axutil_strlen(p_prefix) +
1172
axutil_strlen("statusMessage")));
1174
/* axutil_strlen("<:>") + 1 = 4 */
1175
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1176
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1177
/* axutil_strlen("</:>") + 1 = 5 */
1185
* parsing statusMessage element
1190
sprintf(start_input_str, "<%s%sstatusMessage>",
1191
p_prefix?p_prefix:"",
1192
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1194
start_input_str_len = axutil_strlen(start_input_str);
1195
sprintf(end_input_str, "</%s%sstatusMessage>",
1196
p_prefix?p_prefix:"",
1197
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1198
end_input_str_len = axutil_strlen(end_input_str);
1200
text_value_3 = _describeNetworksType->property_statusMessage;
1202
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1205
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1206
if (text_value_3_temp)
1208
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1209
AXIS2_FREE(env->allocator, text_value_3_temp);
1213
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1216
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1219
AXIS2_FREE(env->allocator,start_input_str);
1220
AXIS2_FREE(env->allocator,end_input_str);
1224
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1226
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1227
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1228
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1230
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1231
"http://eucalyptus.ucsb.edu/",
1236
if (!_describeNetworksType->is_valid_return)
1239
/* no need to complain for minoccurs=0 element */
1245
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1246
(4 + axutil_strlen(p_prefix) +
1247
axutil_strlen("return")));
1249
/* axutil_strlen("<:>") + 1 = 4 */
1250
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1251
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1252
/* axutil_strlen("</:>") + 1 = 5 */
1260
* parsing return element
1265
sprintf(start_input_str, "<%s%sreturn>",
1266
p_prefix?p_prefix:"",
1267
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1269
start_input_str_len = axutil_strlen(start_input_str);
1270
sprintf(end_input_str, "</%s%sreturn>",
1271
p_prefix?p_prefix:"",
1272
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1273
end_input_str_len = axutil_strlen(end_input_str);
1275
strcpy(text_value_4, (_describeNetworksType->property_return)?"true":"false");
1277
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1279
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1281
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1284
AXIS2_FREE(env->allocator,start_input_str);
1285
AXIS2_FREE(env->allocator,end_input_str);
1289
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1291
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1292
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1293
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1295
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1296
"http://eucalyptus.ucsb.edu/",
1301
if (!_describeNetworksType->is_valid_nameserver)
1304
/* no need to complain for minoccurs=0 element */
1310
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1311
(4 + axutil_strlen(p_prefix) +
1312
axutil_strlen("nameserver")));
1314
/* axutil_strlen("<:>") + 1 = 4 */
1315
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1316
(5 + axutil_strlen(p_prefix) + axutil_strlen("nameserver")));
1317
/* axutil_strlen("</:>") + 1 = 5 */
1325
* parsing nameserver element
1330
sprintf(start_input_str, "<%s%snameserver>",
1331
p_prefix?p_prefix:"",
1332
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1334
start_input_str_len = axutil_strlen(start_input_str);
1335
sprintf(end_input_str, "</%s%snameserver>",
1336
p_prefix?p_prefix:"",
1337
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1338
end_input_str_len = axutil_strlen(end_input_str);
1340
text_value_5 = _describeNetworksType->property_nameserver;
1342
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1345
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1346
if (text_value_5_temp)
1348
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1349
AXIS2_FREE(env->allocator, text_value_5_temp);
1353
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1356
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1359
AXIS2_FREE(env->allocator,start_input_str);
1360
AXIS2_FREE(env->allocator,end_input_str);
1364
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1366
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1367
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1368
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1370
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1371
"http://eucalyptus.ucsb.edu/",
1376
if (!_describeNetworksType->is_valid_clusterControllers)
1379
/* no need to complain for minoccurs=0 element */
1385
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1386
(4 + axutil_strlen(p_prefix) +
1387
axutil_strlen("clusterControllers")));
1389
/* axutil_strlen("<:>") + 1 = 4 */
1390
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1391
(5 + axutil_strlen(p_prefix) + axutil_strlen("clusterControllers")));
1392
/* axutil_strlen("</:>") + 1 = 5 */
1399
* Parsing clusterControllers array
1401
if (_describeNetworksType->property_clusterControllers != NULL)
1404
sprintf(start_input_str, "<%s%sclusterControllers>",
1405
p_prefix?p_prefix:"",
1406
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1408
start_input_str_len = axutil_strlen(start_input_str);
1410
sprintf(end_input_str, "</%s%sclusterControllers>",
1411
p_prefix?p_prefix:"",
1412
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1413
end_input_str_len = axutil_strlen(end_input_str);
1415
count = axutil_array_list_size(_describeNetworksType->property_clusterControllers, env);
1416
for(i = 0; i < count; i ++)
1418
element = axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i);
1427
* parsing clusterControllers element
1432
text_value_6 = (axis2_char_t*)element;
1434
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1437
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1438
if (text_value_6_temp)
1440
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1441
AXIS2_FREE(env->allocator, text_value_6_temp);
1445
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1448
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1454
AXIS2_FREE(env->allocator,start_input_str);
1455
AXIS2_FREE(env->allocator,end_input_str);
1467
* getter for correlationId.
1469
axis2_char_t* AXIS2_CALL
1470
adb_describeNetworksType_get_correlationId(
1471
adb_describeNetworksType_t* _describeNetworksType,
1472
const axutil_env_t *env)
1475
AXIS2_ENV_CHECK(env, NULL);
1476
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, NULL);
1479
return _describeNetworksType->property_correlationId;
1483
* setter for correlationId
1485
axis2_status_t AXIS2_CALL
1486
adb_describeNetworksType_set_correlationId(
1487
adb_describeNetworksType_t* _describeNetworksType,
1488
const axutil_env_t *env,
1489
const axis2_char_t* arg_correlationId)
1493
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1494
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1496
if(_describeNetworksType->is_valid_correlationId &&
1497
arg_correlationId == _describeNetworksType->property_correlationId)
1500
return AXIS2_SUCCESS;
1503
adb_describeNetworksType_reset_correlationId(_describeNetworksType, env);
1506
if(NULL == arg_correlationId)
1508
/* We are already done */
1509
return AXIS2_SUCCESS;
1511
_describeNetworksType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1512
if(NULL == _describeNetworksType->property_correlationId)
1514
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1515
return AXIS2_FAILURE;
1517
_describeNetworksType->is_valid_correlationId = AXIS2_TRUE;
1519
return AXIS2_SUCCESS;
1525
* resetter for correlationId
1527
axis2_status_t AXIS2_CALL
1528
adb_describeNetworksType_reset_correlationId(
1529
adb_describeNetworksType_t* _describeNetworksType,
1530
const axutil_env_t *env)
1534
void *element = NULL;
1536
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1537
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1543
if(_describeNetworksType->property_correlationId != NULL)
1547
AXIS2_FREE(env-> allocator, _describeNetworksType->property_correlationId);
1548
_describeNetworksType->property_correlationId = NULL;
1553
_describeNetworksType->is_valid_correlationId = AXIS2_FALSE;
1554
return AXIS2_SUCCESS;
1558
* Check whether correlationId is nill
1560
axis2_bool_t AXIS2_CALL
1561
adb_describeNetworksType_is_correlationId_nil(
1562
adb_describeNetworksType_t* _describeNetworksType,
1563
const axutil_env_t *env)
1565
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1566
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_TRUE);
1568
return !_describeNetworksType->is_valid_correlationId;
1572
* Set correlationId to nill (currently the same as reset)
1574
axis2_status_t AXIS2_CALL
1575
adb_describeNetworksType_set_correlationId_nil(
1576
adb_describeNetworksType_t* _describeNetworksType,
1577
const axutil_env_t *env)
1579
return adb_describeNetworksType_reset_correlationId(_describeNetworksType, env);
1585
* getter for userId.
1587
axis2_char_t* AXIS2_CALL
1588
adb_describeNetworksType_get_userId(
1589
adb_describeNetworksType_t* _describeNetworksType,
1590
const axutil_env_t *env)
1593
AXIS2_ENV_CHECK(env, NULL);
1594
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, NULL);
1597
return _describeNetworksType->property_userId;
1603
axis2_status_t AXIS2_CALL
1604
adb_describeNetworksType_set_userId(
1605
adb_describeNetworksType_t* _describeNetworksType,
1606
const axutil_env_t *env,
1607
const axis2_char_t* arg_userId)
1611
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1612
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1614
if(_describeNetworksType->is_valid_userId &&
1615
arg_userId == _describeNetworksType->property_userId)
1618
return AXIS2_SUCCESS;
1621
adb_describeNetworksType_reset_userId(_describeNetworksType, env);
1624
if(NULL == arg_userId)
1626
/* We are already done */
1627
return AXIS2_SUCCESS;
1629
_describeNetworksType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1630
if(NULL == _describeNetworksType->property_userId)
1632
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1633
return AXIS2_FAILURE;
1635
_describeNetworksType->is_valid_userId = AXIS2_TRUE;
1637
return AXIS2_SUCCESS;
1643
* resetter for userId
1645
axis2_status_t AXIS2_CALL
1646
adb_describeNetworksType_reset_userId(
1647
adb_describeNetworksType_t* _describeNetworksType,
1648
const axutil_env_t *env)
1652
void *element = NULL;
1654
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1655
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1661
if(_describeNetworksType->property_userId != NULL)
1665
AXIS2_FREE(env-> allocator, _describeNetworksType->property_userId);
1666
_describeNetworksType->property_userId = NULL;
1671
_describeNetworksType->is_valid_userId = AXIS2_FALSE;
1672
return AXIS2_SUCCESS;
1676
* Check whether userId is nill
1678
axis2_bool_t AXIS2_CALL
1679
adb_describeNetworksType_is_userId_nil(
1680
adb_describeNetworksType_t* _describeNetworksType,
1681
const axutil_env_t *env)
1683
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1684
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_TRUE);
1686
return !_describeNetworksType->is_valid_userId;
1690
* Set userId to nill (currently the same as reset)
1692
axis2_status_t AXIS2_CALL
1693
adb_describeNetworksType_set_userId_nil(
1694
adb_describeNetworksType_t* _describeNetworksType,
1695
const axutil_env_t *env)
1697
return adb_describeNetworksType_reset_userId(_describeNetworksType, env);
1703
* getter for statusMessage.
1705
axis2_char_t* AXIS2_CALL
1706
adb_describeNetworksType_get_statusMessage(
1707
adb_describeNetworksType_t* _describeNetworksType,
1708
const axutil_env_t *env)
1711
AXIS2_ENV_CHECK(env, NULL);
1712
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, NULL);
1715
return _describeNetworksType->property_statusMessage;
1719
* setter for statusMessage
1721
axis2_status_t AXIS2_CALL
1722
adb_describeNetworksType_set_statusMessage(
1723
adb_describeNetworksType_t* _describeNetworksType,
1724
const axutil_env_t *env,
1725
const axis2_char_t* arg_statusMessage)
1729
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1730
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1732
if(_describeNetworksType->is_valid_statusMessage &&
1733
arg_statusMessage == _describeNetworksType->property_statusMessage)
1736
return AXIS2_SUCCESS;
1739
adb_describeNetworksType_reset_statusMessage(_describeNetworksType, env);
1742
if(NULL == arg_statusMessage)
1744
/* We are already done */
1745
return AXIS2_SUCCESS;
1747
_describeNetworksType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1748
if(NULL == _describeNetworksType->property_statusMessage)
1750
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1751
return AXIS2_FAILURE;
1753
_describeNetworksType->is_valid_statusMessage = AXIS2_TRUE;
1755
return AXIS2_SUCCESS;
1761
* resetter for statusMessage
1763
axis2_status_t AXIS2_CALL
1764
adb_describeNetworksType_reset_statusMessage(
1765
adb_describeNetworksType_t* _describeNetworksType,
1766
const axutil_env_t *env)
1770
void *element = NULL;
1772
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1773
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1779
if(_describeNetworksType->property_statusMessage != NULL)
1783
AXIS2_FREE(env-> allocator, _describeNetworksType->property_statusMessage);
1784
_describeNetworksType->property_statusMessage = NULL;
1789
_describeNetworksType->is_valid_statusMessage = AXIS2_FALSE;
1790
return AXIS2_SUCCESS;
1794
* Check whether statusMessage is nill
1796
axis2_bool_t AXIS2_CALL
1797
adb_describeNetworksType_is_statusMessage_nil(
1798
adb_describeNetworksType_t* _describeNetworksType,
1799
const axutil_env_t *env)
1801
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1802
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_TRUE);
1804
return !_describeNetworksType->is_valid_statusMessage;
1808
* Set statusMessage to nill (currently the same as reset)
1810
axis2_status_t AXIS2_CALL
1811
adb_describeNetworksType_set_statusMessage_nil(
1812
adb_describeNetworksType_t* _describeNetworksType,
1813
const axutil_env_t *env)
1815
return adb_describeNetworksType_reset_statusMessage(_describeNetworksType, env);
1821
* getter for return.
1823
axis2_bool_t AXIS2_CALL
1824
adb_describeNetworksType_get_return(
1825
adb_describeNetworksType_t* _describeNetworksType,
1826
const axutil_env_t *env)
1829
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1830
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, (axis2_bool_t)0);
1833
return _describeNetworksType->property_return;
1839
axis2_status_t AXIS2_CALL
1840
adb_describeNetworksType_set_return(
1841
adb_describeNetworksType_t* _describeNetworksType,
1842
const axutil_env_t *env,
1843
axis2_bool_t arg_return)
1847
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1848
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1850
if(_describeNetworksType->is_valid_return &&
1851
arg_return == _describeNetworksType->property_return)
1854
return AXIS2_SUCCESS;
1857
adb_describeNetworksType_reset_return(_describeNetworksType, env);
1859
_describeNetworksType->property_return = arg_return;
1860
_describeNetworksType->is_valid_return = AXIS2_TRUE;
1862
return AXIS2_SUCCESS;
1868
* resetter for return
1870
axis2_status_t AXIS2_CALL
1871
adb_describeNetworksType_reset_return(
1872
adb_describeNetworksType_t* _describeNetworksType,
1873
const axutil_env_t *env)
1877
void *element = NULL;
1879
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1880
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1883
_describeNetworksType->is_valid_return = AXIS2_FALSE;
1884
return AXIS2_SUCCESS;
1888
* Check whether return is nill
1890
axis2_bool_t AXIS2_CALL
1891
adb_describeNetworksType_is_return_nil(
1892
adb_describeNetworksType_t* _describeNetworksType,
1893
const axutil_env_t *env)
1895
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1896
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_TRUE);
1898
return !_describeNetworksType->is_valid_return;
1902
* Set return to nill (currently the same as reset)
1904
axis2_status_t AXIS2_CALL
1905
adb_describeNetworksType_set_return_nil(
1906
adb_describeNetworksType_t* _describeNetworksType,
1907
const axutil_env_t *env)
1909
return adb_describeNetworksType_reset_return(_describeNetworksType, env);
1915
* getter for nameserver.
1917
axis2_char_t* AXIS2_CALL
1918
adb_describeNetworksType_get_nameserver(
1919
adb_describeNetworksType_t* _describeNetworksType,
1920
const axutil_env_t *env)
1923
AXIS2_ENV_CHECK(env, NULL);
1924
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, NULL);
1927
return _describeNetworksType->property_nameserver;
1931
* setter for nameserver
1933
axis2_status_t AXIS2_CALL
1934
adb_describeNetworksType_set_nameserver(
1935
adb_describeNetworksType_t* _describeNetworksType,
1936
const axutil_env_t *env,
1937
const axis2_char_t* arg_nameserver)
1941
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1942
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1944
if(_describeNetworksType->is_valid_nameserver &&
1945
arg_nameserver == _describeNetworksType->property_nameserver)
1948
return AXIS2_SUCCESS;
1951
adb_describeNetworksType_reset_nameserver(_describeNetworksType, env);
1954
if(NULL == arg_nameserver)
1956
/* We are already done */
1957
return AXIS2_SUCCESS;
1959
_describeNetworksType->property_nameserver = (axis2_char_t *)axutil_strdup(env, arg_nameserver);
1960
if(NULL == _describeNetworksType->property_nameserver)
1962
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nameserver");
1963
return AXIS2_FAILURE;
1965
_describeNetworksType->is_valid_nameserver = AXIS2_TRUE;
1967
return AXIS2_SUCCESS;
1973
* resetter for nameserver
1975
axis2_status_t AXIS2_CALL
1976
adb_describeNetworksType_reset_nameserver(
1977
adb_describeNetworksType_t* _describeNetworksType,
1978
const axutil_env_t *env)
1982
void *element = NULL;
1984
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1985
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
1991
if(_describeNetworksType->property_nameserver != NULL)
1995
AXIS2_FREE(env-> allocator, _describeNetworksType->property_nameserver);
1996
_describeNetworksType->property_nameserver = NULL;
2001
_describeNetworksType->is_valid_nameserver = AXIS2_FALSE;
2002
return AXIS2_SUCCESS;
2006
* Check whether nameserver is nill
2008
axis2_bool_t AXIS2_CALL
2009
adb_describeNetworksType_is_nameserver_nil(
2010
adb_describeNetworksType_t* _describeNetworksType,
2011
const axutil_env_t *env)
2013
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2014
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_TRUE);
2016
return !_describeNetworksType->is_valid_nameserver;
2020
* Set nameserver to nill (currently the same as reset)
2022
axis2_status_t AXIS2_CALL
2023
adb_describeNetworksType_set_nameserver_nil(
2024
adb_describeNetworksType_t* _describeNetworksType,
2025
const axutil_env_t *env)
2027
return adb_describeNetworksType_reset_nameserver(_describeNetworksType, env);
2033
* getter for clusterControllers.
2035
axutil_array_list_t* AXIS2_CALL
2036
adb_describeNetworksType_get_clusterControllers(
2037
adb_describeNetworksType_t* _describeNetworksType,
2038
const axutil_env_t *env)
2041
AXIS2_ENV_CHECK(env, NULL);
2042
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, NULL);
2045
return _describeNetworksType->property_clusterControllers;
2049
* setter for clusterControllers
2051
axis2_status_t AXIS2_CALL
2052
adb_describeNetworksType_set_clusterControllers(
2053
adb_describeNetworksType_t* _describeNetworksType,
2054
const axutil_env_t *env,
2055
axutil_array_list_t* arg_clusterControllers)
2060
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2063
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2064
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
2066
if(_describeNetworksType->is_valid_clusterControllers &&
2067
arg_clusterControllers == _describeNetworksType->property_clusterControllers)
2070
return AXIS2_SUCCESS;
2074
size = axutil_array_list_size(arg_clusterControllers, env);
2078
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "clusterControllers has less than minOccurs(0)");
2079
return AXIS2_FAILURE;
2081
for(i = 0; i < size; i ++ )
2083
if(NULL != axutil_array_list_get(arg_clusterControllers, env, i))
2085
non_nil_exists = AXIS2_TRUE;
2090
adb_describeNetworksType_reset_clusterControllers(_describeNetworksType, env);
2093
if(NULL == arg_clusterControllers)
2095
/* We are already done */
2096
return AXIS2_SUCCESS;
2098
_describeNetworksType->property_clusterControllers = arg_clusterControllers;
2101
_describeNetworksType->is_valid_clusterControllers = AXIS2_TRUE;
2105
return AXIS2_SUCCESS;
2110
* Get ith element of clusterControllers.
2112
axis2_char_t* AXIS2_CALL
2113
adb_describeNetworksType_get_clusterControllers_at(
2114
adb_describeNetworksType_t* _describeNetworksType,
2115
const axutil_env_t *env, int i)
2117
axis2_char_t* ret_val;
2120
AXIS2_ENV_CHECK(env, NULL);
2121
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, NULL);
2124
if(_describeNetworksType->property_clusterControllers == NULL)
2126
return (axis2_char_t*)0;
2128
ret_val = (axis2_char_t*)axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i);
2135
* Set the ith element of clusterControllers.
2137
axis2_status_t AXIS2_CALL
2138
adb_describeNetworksType_set_clusterControllers_at(
2139
adb_describeNetworksType_t* _describeNetworksType,
2140
const axutil_env_t *env, int i,
2141
const axis2_char_t* arg_clusterControllers)
2143
void *element = NULL;
2147
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2151
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2152
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
2154
if( _describeNetworksType->is_valid_clusterControllers &&
2155
_describeNetworksType->property_clusterControllers &&
2157
arg_clusterControllers == (axis2_char_t*)axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i))
2161
return AXIS2_SUCCESS;
2165
if(NULL == arg_clusterControllers)
2167
if(_describeNetworksType->property_clusterControllers != NULL)
2169
size = axutil_array_list_size(_describeNetworksType->property_clusterControllers, env);
2170
for(j = 0, k = 0; j < size; j ++ )
2172
if(i == j) continue;
2173
if(NULL != axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i))
2176
non_nil_exists = AXIS2_TRUE;
2187
non_nil_exists = AXIS2_TRUE;
2192
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of clusterControllers is beinng set to be smaller than the specificed number of minOccurs(0)");
2193
return AXIS2_FAILURE;
2196
if(_describeNetworksType->property_clusterControllers == NULL)
2198
_describeNetworksType->property_clusterControllers = axutil_array_list_create(env, 10);
2201
/* check whether there already exist an element */
2202
element = axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i);
2208
/* This is an unknown type or a primitive. Please free this manually*/
2216
_describeNetworksType->is_valid_clusterControllers = AXIS2_FALSE;
2217
axutil_array_list_set(_describeNetworksType->property_clusterControllers , env, i, NULL);
2219
return AXIS2_SUCCESS;
2222
axutil_array_list_set(_describeNetworksType->property_clusterControllers , env, i, axutil_strdup(env, arg_clusterControllers));
2223
_describeNetworksType->is_valid_clusterControllers = AXIS2_TRUE;
2225
return AXIS2_SUCCESS;
2229
* Add to clusterControllers.
2231
axis2_status_t AXIS2_CALL
2232
adb_describeNetworksType_add_clusterControllers(
2233
adb_describeNetworksType_t* _describeNetworksType,
2234
const axutil_env_t *env,
2235
const axis2_char_t* arg_clusterControllers)
2239
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2240
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
2243
if(NULL == arg_clusterControllers)
2246
return AXIS2_SUCCESS;
2251
if(_describeNetworksType->property_clusterControllers == NULL)
2253
_describeNetworksType->property_clusterControllers = axutil_array_list_create(env, 10);
2255
if(_describeNetworksType->property_clusterControllers == NULL)
2257
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for clusterControllers");
2258
return AXIS2_FAILURE;
2262
axutil_array_list_add(_describeNetworksType->property_clusterControllers , env, axutil_strdup(env, arg_clusterControllers));
2263
_describeNetworksType->is_valid_clusterControllers = AXIS2_TRUE;
2264
return AXIS2_SUCCESS;
2268
* Get the size of the clusterControllers array.
2271
adb_describeNetworksType_sizeof_clusterControllers(
2272
adb_describeNetworksType_t* _describeNetworksType,
2273
const axutil_env_t *env)
2275
AXIS2_ENV_CHECK(env, -1);
2276
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, -1);
2277
if(_describeNetworksType->property_clusterControllers == NULL)
2281
return axutil_array_list_size(_describeNetworksType->property_clusterControllers, env);
2285
* remove the ith element, same as set_nil_at.
2287
axis2_status_t AXIS2_CALL
2288
adb_describeNetworksType_remove_clusterControllers_at(
2289
adb_describeNetworksType_t* _describeNetworksType,
2290
const axutil_env_t *env, int i)
2292
return adb_describeNetworksType_set_clusterControllers_nil_at(_describeNetworksType, env, i);
2298
* resetter for clusterControllers
2300
axis2_status_t AXIS2_CALL
2301
adb_describeNetworksType_reset_clusterControllers(
2302
adb_describeNetworksType_t* _describeNetworksType,
2303
const axutil_env_t *env)
2307
void *element = NULL;
2309
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2310
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
2314
if (_describeNetworksType->property_clusterControllers != NULL)
2316
count = axutil_array_list_size(_describeNetworksType->property_clusterControllers, env);
2317
for(i = 0; i < count; i ++)
2319
element = axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i);
2327
AXIS2_FREE(env-> allocator, (axis2_char_t*)element);
2335
axutil_array_list_free(_describeNetworksType->property_clusterControllers, env);
2337
_describeNetworksType->is_valid_clusterControllers = AXIS2_FALSE;
2338
return AXIS2_SUCCESS;
2342
* Check whether clusterControllers is nill
2344
axis2_bool_t AXIS2_CALL
2345
adb_describeNetworksType_is_clusterControllers_nil(
2346
adb_describeNetworksType_t* _describeNetworksType,
2347
const axutil_env_t *env)
2349
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2350
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_TRUE);
2352
return !_describeNetworksType->is_valid_clusterControllers;
2356
* Set clusterControllers to nill (currently the same as reset)
2358
axis2_status_t AXIS2_CALL
2359
adb_describeNetworksType_set_clusterControllers_nil(
2360
adb_describeNetworksType_t* _describeNetworksType,
2361
const axutil_env_t *env)
2363
return adb_describeNetworksType_reset_clusterControllers(_describeNetworksType, env);
2368
* Check whether clusterControllers is nill at i
2370
axis2_bool_t AXIS2_CALL
2371
adb_describeNetworksType_is_clusterControllers_nil_at(
2372
adb_describeNetworksType_t* _describeNetworksType,
2373
const axutil_env_t *env, int i)
2375
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2376
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_TRUE);
2378
return (_describeNetworksType->is_valid_clusterControllers == AXIS2_FALSE ||
2379
NULL == _describeNetworksType->property_clusterControllers ||
2380
NULL == axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i));
2384
* Set clusterControllers to nill at i
2386
axis2_status_t AXIS2_CALL
2387
adb_describeNetworksType_set_clusterControllers_nil_at(
2388
adb_describeNetworksType_t* _describeNetworksType,
2389
const axutil_env_t *env, int i)
2391
void *element = NULL;
2394
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2398
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2399
AXIS2_PARAM_CHECK(env->error, _describeNetworksType, AXIS2_FAILURE);
2401
if(_describeNetworksType->property_clusterControllers == NULL ||
2402
_describeNetworksType->is_valid_clusterControllers == AXIS2_FALSE)
2405
non_nil_exists = AXIS2_FALSE;
2409
size = axutil_array_list_size(_describeNetworksType->property_clusterControllers, env);
2410
for(j = 0, k = 0; j < size; j ++ )
2412
if(i == j) continue;
2413
if(NULL != axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i))
2416
non_nil_exists = AXIS2_TRUE;
2428
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of clusterControllers is beinng set to be smaller than the specificed number of minOccurs(0)");
2429
return AXIS2_FAILURE;
2432
if(_describeNetworksType->property_clusterControllers == NULL)
2434
_describeNetworksType->is_valid_clusterControllers = AXIS2_FALSE;
2436
return AXIS2_SUCCESS;
2439
/* check whether there already exist an element */
2440
element = axutil_array_list_get(_describeNetworksType->property_clusterControllers, env, i);
2446
/* This is an unknown type or a primitive. Please free this manually*/
2454
_describeNetworksType->is_valid_clusterControllers = AXIS2_FALSE;
2455
axutil_array_list_set(_describeNetworksType->property_clusterControllers , env, i, NULL);
2456
return AXIS2_SUCCESS;
2461
axutil_array_list_set(_describeNetworksType->property_clusterControllers , env, i, NULL);
2463
return AXIS2_SUCCESS;
added
removed
cluster/generated/adb_describeNetworksType.c
