4
* adb_ncDescribeResourceResponseType.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_ncDescribeResourceResponseType.h"
13
* This type was generated from the piece of schema that had
14
* name = ncDescribeResourceResponseType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_ncDescribeResourceResponseType
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_bool_t property_return;
38
axis2_bool_t is_valid_return;
41
axis2_char_t* property_nodeName;
44
axis2_bool_t is_valid_nodeName;
47
int property_statusMessage;
50
axis2_bool_t is_valid_statusMessage;
53
axis2_char_t* property_nodeStatus;
56
axis2_bool_t is_valid_nodeStatus;
59
int property_memorySizeMax;
62
axis2_bool_t is_valid_memorySizeMax;
65
int property_memorySizeAvailable;
68
axis2_bool_t is_valid_memorySizeAvailable;
71
int property_diskSizeMax;
74
axis2_bool_t is_valid_diskSizeMax;
77
int property_diskSizeAvailable;
80
axis2_bool_t is_valid_diskSizeAvailable;
83
int property_numberOfCoresMax;
86
axis2_bool_t is_valid_numberOfCoresMax;
89
int property_numberOfCoresAvailable;
92
axis2_bool_t is_valid_numberOfCoresAvailable;
95
axis2_char_t* property_publicSubnets;
98
axis2_bool_t is_valid_publicSubnets;
105
/************************* Private Function prototypes ********************************/
108
axis2_status_t AXIS2_CALL
109
adb_ncDescribeResourceResponseType_set_userId_nil(
110
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
111
const axutil_env_t *env);
114
axis2_status_t AXIS2_CALL
115
adb_ncDescribeResourceResponseType_set_return_nil(
116
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
117
const axutil_env_t *env);
120
axis2_status_t AXIS2_CALL
121
adb_ncDescribeResourceResponseType_set_nodeStatus_nil(
122
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
123
const axutil_env_t *env);
126
axis2_status_t AXIS2_CALL
127
adb_ncDescribeResourceResponseType_set_memorySizeMax_nil(
128
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
129
const axutil_env_t *env);
132
axis2_status_t AXIS2_CALL
133
adb_ncDescribeResourceResponseType_set_memorySizeAvailable_nil(
134
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
135
const axutil_env_t *env);
138
axis2_status_t AXIS2_CALL
139
adb_ncDescribeResourceResponseType_set_diskSizeMax_nil(
140
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
141
const axutil_env_t *env);
144
axis2_status_t AXIS2_CALL
145
adb_ncDescribeResourceResponseType_set_diskSizeAvailable_nil(
146
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
147
const axutil_env_t *env);
150
axis2_status_t AXIS2_CALL
151
adb_ncDescribeResourceResponseType_set_numberOfCoresMax_nil(
152
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
153
const axutil_env_t *env);
156
axis2_status_t AXIS2_CALL
157
adb_ncDescribeResourceResponseType_set_numberOfCoresAvailable_nil(
158
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
159
const axutil_env_t *env);
162
axis2_status_t AXIS2_CALL
163
adb_ncDescribeResourceResponseType_set_publicSubnets_nil(
164
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
165
const axutil_env_t *env);
169
/************************* Function Implmentations ********************************/
170
adb_ncDescribeResourceResponseType_t* AXIS2_CALL
171
adb_ncDescribeResourceResponseType_create(
172
const axutil_env_t *env)
174
adb_ncDescribeResourceResponseType_t *_ncDescribeResourceResponseType = NULL;
176
AXIS2_ENV_CHECK(env, NULL);
178
_ncDescribeResourceResponseType = (adb_ncDescribeResourceResponseType_t *) AXIS2_MALLOC(env->
179
allocator, sizeof(adb_ncDescribeResourceResponseType_t));
181
if(NULL == _ncDescribeResourceResponseType)
183
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
187
memset(_ncDescribeResourceResponseType, 0, sizeof(adb_ncDescribeResourceResponseType_t));
189
_ncDescribeResourceResponseType->property_correlationId = NULL;
190
_ncDescribeResourceResponseType->is_valid_correlationId = AXIS2_FALSE;
191
_ncDescribeResourceResponseType->property_userId = NULL;
192
_ncDescribeResourceResponseType->is_valid_userId = AXIS2_FALSE;
193
_ncDescribeResourceResponseType->is_valid_return = AXIS2_FALSE;
194
_ncDescribeResourceResponseType->property_nodeName = NULL;
195
_ncDescribeResourceResponseType->is_valid_nodeName = AXIS2_FALSE;
196
_ncDescribeResourceResponseType->is_valid_statusMessage = AXIS2_FALSE;
197
_ncDescribeResourceResponseType->property_nodeStatus = NULL;
198
_ncDescribeResourceResponseType->is_valid_nodeStatus = AXIS2_FALSE;
199
_ncDescribeResourceResponseType->is_valid_memorySizeMax = AXIS2_FALSE;
200
_ncDescribeResourceResponseType->is_valid_memorySizeAvailable = AXIS2_FALSE;
201
_ncDescribeResourceResponseType->is_valid_diskSizeMax = AXIS2_FALSE;
202
_ncDescribeResourceResponseType->is_valid_diskSizeAvailable = AXIS2_FALSE;
203
_ncDescribeResourceResponseType->is_valid_numberOfCoresMax = AXIS2_FALSE;
204
_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable = AXIS2_FALSE;
205
_ncDescribeResourceResponseType->property_publicSubnets = NULL;
206
_ncDescribeResourceResponseType->is_valid_publicSubnets = AXIS2_FALSE;
209
return _ncDescribeResourceResponseType;
212
axis2_status_t AXIS2_CALL
213
adb_ncDescribeResourceResponseType_free (
214
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
215
const axutil_env_t *env)
219
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
220
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
222
adb_ncDescribeResourceResponseType_reset_correlationId(_ncDescribeResourceResponseType, env);
223
adb_ncDescribeResourceResponseType_reset_userId(_ncDescribeResourceResponseType, env);
224
adb_ncDescribeResourceResponseType_reset_return(_ncDescribeResourceResponseType, env);
225
adb_ncDescribeResourceResponseType_reset_nodeName(_ncDescribeResourceResponseType, env);
226
adb_ncDescribeResourceResponseType_reset_statusMessage(_ncDescribeResourceResponseType, env);
227
adb_ncDescribeResourceResponseType_reset_nodeStatus(_ncDescribeResourceResponseType, env);
228
adb_ncDescribeResourceResponseType_reset_memorySizeMax(_ncDescribeResourceResponseType, env);
229
adb_ncDescribeResourceResponseType_reset_memorySizeAvailable(_ncDescribeResourceResponseType, env);
230
adb_ncDescribeResourceResponseType_reset_diskSizeMax(_ncDescribeResourceResponseType, env);
231
adb_ncDescribeResourceResponseType_reset_diskSizeAvailable(_ncDescribeResourceResponseType, env);
232
adb_ncDescribeResourceResponseType_reset_numberOfCoresMax(_ncDescribeResourceResponseType, env);
233
adb_ncDescribeResourceResponseType_reset_numberOfCoresAvailable(_ncDescribeResourceResponseType, env);
234
adb_ncDescribeResourceResponseType_reset_publicSubnets(_ncDescribeResourceResponseType, env);
237
if(_ncDescribeResourceResponseType)
239
AXIS2_FREE(env->allocator, _ncDescribeResourceResponseType);
240
_ncDescribeResourceResponseType = NULL;
242
return AXIS2_SUCCESS;
248
axis2_status_t AXIS2_CALL
249
adb_ncDescribeResourceResponseType_deserialize(
250
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
251
const axutil_env_t *env,
252
axiom_node_t **dp_parent,
253
axis2_bool_t *dp_is_early_node_valid,
254
axis2_bool_t dont_care_minoccurs)
256
axiom_node_t *parent = *dp_parent;
258
axis2_status_t status = AXIS2_SUCCESS;
260
axis2_char_t* text_value = NULL;
261
axutil_qname_t *qname = NULL;
263
axutil_qname_t *element_qname = NULL;
265
axiom_node_t *first_node = NULL;
266
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
267
axiom_node_t *current_node = NULL;
268
axiom_element_t *current_element = NULL;
270
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
271
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
275
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
277
parent = axiom_node_get_next_sibling(parent, env);
281
/* This should be checked before everything */
282
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
283
"Failed in building adb object for ncDescribeResourceResponseType : "
284
"NULL elemenet can not be passed to deserialize");
285
return AXIS2_FAILURE;
289
first_node = axiom_node_get_first_child(parent, env);
295
* building correlationId element
300
current_node = first_node;
301
is_early_node_valid = AXIS2_FALSE;
304
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
306
current_node = axiom_node_get_next_sibling(current_node, env);
308
if(current_node != NULL)
310
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
311
qname = axiom_element_get_qname(current_element, env, current_node);
314
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
318
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
320
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
322
is_early_node_valid = AXIS2_TRUE;
326
text_value = axiom_element_get_text(current_element, env, current_node);
327
if(text_value != NULL)
329
status = adb_ncDescribeResourceResponseType_set_correlationId(_ncDescribeResourceResponseType, env,
333
if(AXIS2_FAILURE == status)
335
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
338
axutil_qname_free(element_qname, env);
340
return AXIS2_FAILURE;
346
axutil_qname_free(element_qname, env);
347
element_qname = NULL;
353
* building userId element
359
* because elements are ordered this works fine
363
if(current_node != NULL && is_early_node_valid)
365
current_node = axiom_node_get_next_sibling(current_node, env);
368
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
370
current_node = axiom_node_get_next_sibling(current_node, env);
372
if(current_node != NULL)
374
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
375
qname = axiom_element_get_qname(current_element, env, current_node);
379
is_early_node_valid = AXIS2_FALSE;
381
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
385
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
387
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
389
is_early_node_valid = AXIS2_TRUE;
393
text_value = axiom_element_get_text(current_element, env, current_node);
394
if(text_value != NULL)
396
status = adb_ncDescribeResourceResponseType_set_userId(_ncDescribeResourceResponseType, env,
403
* axis2_qname_t *qname = NULL;
404
* axiom_attribute_t *the_attri = NULL;
406
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
407
* the_attri = axiom_element_get_attribute(current_element, env, qname);
409
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
411
axiom_attribute_t *the_attri = NULL;
412
axis2_char_t *attrib_text = NULL;
413
axutil_hash_t *attribute_hash = NULL;
415
attribute_hash = axiom_element_get_all_attributes(current_element, env);
420
axutil_hash_index_t *hi;
424
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
426
axutil_hash_this(hi, &key, NULL, &val);
428
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
430
the_attri = (axiom_attribute_t*)val;
438
attrib_text = axiom_attribute_get_value(the_attri, env);
442
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
443
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
446
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
448
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
449
status = AXIS2_FAILURE;
453
/* after all, we found this is a empty string */
454
status = adb_ncDescribeResourceResponseType_set_userId(_ncDescribeResourceResponseType, env,
459
if(AXIS2_FAILURE == status)
461
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
464
axutil_qname_free(element_qname, env);
466
return AXIS2_FAILURE;
472
axutil_qname_free(element_qname, env);
473
element_qname = NULL;
479
* building return element
485
* because elements are ordered this works fine
489
if(current_node != NULL && is_early_node_valid)
491
current_node = axiom_node_get_next_sibling(current_node, env);
494
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
496
current_node = axiom_node_get_next_sibling(current_node, env);
498
if(current_node != NULL)
500
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
501
qname = axiom_element_get_qname(current_element, env, current_node);
505
is_early_node_valid = AXIS2_FALSE;
507
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
511
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
513
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
515
is_early_node_valid = AXIS2_TRUE;
519
text_value = axiom_element_get_text(current_element, env, current_node);
520
if(text_value != NULL)
522
if (!axutil_strcasecmp(text_value , "true"))
524
status = adb_ncDescribeResourceResponseType_set_return(_ncDescribeResourceResponseType, env,
529
status = adb_ncDescribeResourceResponseType_set_return(_ncDescribeResourceResponseType, env,
536
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
537
status = AXIS2_FAILURE;
540
if(AXIS2_FAILURE == status)
542
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
545
axutil_qname_free(element_qname, env);
547
return AXIS2_FAILURE;
553
axutil_qname_free(element_qname, env);
554
element_qname = NULL;
560
* building nodeName element
566
* because elements are ordered this works fine
570
if(current_node != NULL && is_early_node_valid)
572
current_node = axiom_node_get_next_sibling(current_node, env);
575
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
577
current_node = axiom_node_get_next_sibling(current_node, env);
579
if(current_node != NULL)
581
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
582
qname = axiom_element_get_qname(current_element, env, current_node);
586
is_early_node_valid = AXIS2_FALSE;
588
element_qname = axutil_qname_create(env, "nodeName", "http://eucalyptus.ucsb.edu/", NULL);
592
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
594
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
596
is_early_node_valid = AXIS2_TRUE;
600
text_value = axiom_element_get_text(current_element, env, current_node);
601
if(text_value != NULL)
603
status = adb_ncDescribeResourceResponseType_set_nodeName(_ncDescribeResourceResponseType, env,
607
if(AXIS2_FAILURE == status)
609
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeName ");
612
axutil_qname_free(element_qname, env);
614
return AXIS2_FAILURE;
620
axutil_qname_free(element_qname, env);
621
element_qname = NULL;
627
* building statusMessage element
633
* because elements are ordered this works fine
637
if(current_node != NULL && is_early_node_valid)
639
current_node = axiom_node_get_next_sibling(current_node, env);
642
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
644
current_node = axiom_node_get_next_sibling(current_node, env);
646
if(current_node != NULL)
648
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
649
qname = axiom_element_get_qname(current_element, env, current_node);
653
is_early_node_valid = AXIS2_FALSE;
655
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
659
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
661
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
663
is_early_node_valid = AXIS2_TRUE;
667
text_value = axiom_element_get_text(current_element, env, current_node);
668
if(text_value != NULL)
670
status = adb_ncDescribeResourceResponseType_set_statusMessage(_ncDescribeResourceResponseType, env,
674
if(AXIS2_FAILURE == status)
676
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
679
axutil_qname_free(element_qname, env);
681
return AXIS2_FAILURE;
687
axutil_qname_free(element_qname, env);
688
element_qname = NULL;
694
* building nodeStatus element
700
* because elements are ordered this works fine
704
if(current_node != NULL && is_early_node_valid)
706
current_node = axiom_node_get_next_sibling(current_node, env);
709
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
711
current_node = axiom_node_get_next_sibling(current_node, env);
713
if(current_node != NULL)
715
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
716
qname = axiom_element_get_qname(current_element, env, current_node);
720
is_early_node_valid = AXIS2_FALSE;
722
element_qname = axutil_qname_create(env, "nodeStatus", "http://eucalyptus.ucsb.edu/", NULL);
726
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
728
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
730
is_early_node_valid = AXIS2_TRUE;
734
text_value = axiom_element_get_text(current_element, env, current_node);
735
if(text_value != NULL)
737
status = adb_ncDescribeResourceResponseType_set_nodeStatus(_ncDescribeResourceResponseType, env,
744
* axis2_qname_t *qname = NULL;
745
* axiom_attribute_t *the_attri = NULL;
747
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
748
* the_attri = axiom_element_get_attribute(current_element, env, qname);
750
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
752
axiom_attribute_t *the_attri = NULL;
753
axis2_char_t *attrib_text = NULL;
754
axutil_hash_t *attribute_hash = NULL;
756
attribute_hash = axiom_element_get_all_attributes(current_element, env);
761
axutil_hash_index_t *hi;
765
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
767
axutil_hash_this(hi, &key, NULL, &val);
769
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
771
the_attri = (axiom_attribute_t*)val;
779
attrib_text = axiom_attribute_get_value(the_attri, env);
783
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
784
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
787
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
789
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element nodeStatus");
790
status = AXIS2_FAILURE;
794
/* after all, we found this is a empty string */
795
status = adb_ncDescribeResourceResponseType_set_nodeStatus(_ncDescribeResourceResponseType, env,
800
if(AXIS2_FAILURE == status)
802
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeStatus ");
805
axutil_qname_free(element_qname, env);
807
return AXIS2_FAILURE;
811
else if(!dont_care_minoccurs)
815
axutil_qname_free(element_qname, env);
817
/* this is not a nillable element*/
818
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element nodeStatus missing");
819
return AXIS2_FAILURE;
824
axutil_qname_free(element_qname, env);
825
element_qname = NULL;
831
* building memorySizeMax element
837
* because elements are ordered this works fine
841
if(current_node != NULL && is_early_node_valid)
843
current_node = axiom_node_get_next_sibling(current_node, env);
846
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
848
current_node = axiom_node_get_next_sibling(current_node, env);
850
if(current_node != NULL)
852
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
853
qname = axiom_element_get_qname(current_element, env, current_node);
857
is_early_node_valid = AXIS2_FALSE;
859
element_qname = axutil_qname_create(env, "memorySizeMax", "http://eucalyptus.ucsb.edu/", NULL);
863
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
865
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
867
is_early_node_valid = AXIS2_TRUE;
871
text_value = axiom_element_get_text(current_element, env, current_node);
872
if(text_value != NULL)
874
status = adb_ncDescribeResourceResponseType_set_memorySizeMax(_ncDescribeResourceResponseType, env,
880
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element memorySizeMax");
881
status = AXIS2_FAILURE;
884
if(AXIS2_FAILURE == status)
886
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for memorySizeMax ");
889
axutil_qname_free(element_qname, env);
891
return AXIS2_FAILURE;
895
else if(!dont_care_minoccurs)
899
axutil_qname_free(element_qname, env);
901
/* this is not a nillable element*/
902
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element memorySizeMax missing");
903
return AXIS2_FAILURE;
908
axutil_qname_free(element_qname, env);
909
element_qname = NULL;
915
* building memorySizeAvailable element
921
* because elements are ordered this works fine
925
if(current_node != NULL && is_early_node_valid)
927
current_node = axiom_node_get_next_sibling(current_node, env);
930
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
932
current_node = axiom_node_get_next_sibling(current_node, env);
934
if(current_node != NULL)
936
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
937
qname = axiom_element_get_qname(current_element, env, current_node);
941
is_early_node_valid = AXIS2_FALSE;
943
element_qname = axutil_qname_create(env, "memorySizeAvailable", "http://eucalyptus.ucsb.edu/", NULL);
947
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
949
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
951
is_early_node_valid = AXIS2_TRUE;
955
text_value = axiom_element_get_text(current_element, env, current_node);
956
if(text_value != NULL)
958
status = adb_ncDescribeResourceResponseType_set_memorySizeAvailable(_ncDescribeResourceResponseType, env,
964
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element memorySizeAvailable");
965
status = AXIS2_FAILURE;
968
if(AXIS2_FAILURE == status)
970
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for memorySizeAvailable ");
973
axutil_qname_free(element_qname, env);
975
return AXIS2_FAILURE;
979
else if(!dont_care_minoccurs)
983
axutil_qname_free(element_qname, env);
985
/* this is not a nillable element*/
986
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element memorySizeAvailable missing");
987
return AXIS2_FAILURE;
992
axutil_qname_free(element_qname, env);
993
element_qname = NULL;
999
* building diskSizeMax element
1005
* because elements are ordered this works fine
1009
if(current_node != NULL && is_early_node_valid)
1011
current_node = axiom_node_get_next_sibling(current_node, env);
1014
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1016
current_node = axiom_node_get_next_sibling(current_node, env);
1018
if(current_node != NULL)
1020
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1021
qname = axiom_element_get_qname(current_element, env, current_node);
1025
is_early_node_valid = AXIS2_FALSE;
1027
element_qname = axutil_qname_create(env, "diskSizeMax", "http://eucalyptus.ucsb.edu/", NULL);
1031
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1033
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1035
is_early_node_valid = AXIS2_TRUE;
1039
text_value = axiom_element_get_text(current_element, env, current_node);
1040
if(text_value != NULL)
1042
status = adb_ncDescribeResourceResponseType_set_diskSizeMax(_ncDescribeResourceResponseType, env,
1048
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element diskSizeMax");
1049
status = AXIS2_FAILURE;
1052
if(AXIS2_FAILURE == status)
1054
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for diskSizeMax ");
1057
axutil_qname_free(element_qname, env);
1059
return AXIS2_FAILURE;
1063
else if(!dont_care_minoccurs)
1067
axutil_qname_free(element_qname, env);
1069
/* this is not a nillable element*/
1070
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element diskSizeMax missing");
1071
return AXIS2_FAILURE;
1076
axutil_qname_free(element_qname, env);
1077
element_qname = NULL;
1083
* building diskSizeAvailable element
1089
* because elements are ordered this works fine
1093
if(current_node != NULL && is_early_node_valid)
1095
current_node = axiom_node_get_next_sibling(current_node, env);
1098
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1100
current_node = axiom_node_get_next_sibling(current_node, env);
1102
if(current_node != NULL)
1104
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1105
qname = axiom_element_get_qname(current_element, env, current_node);
1109
is_early_node_valid = AXIS2_FALSE;
1111
element_qname = axutil_qname_create(env, "diskSizeAvailable", "http://eucalyptus.ucsb.edu/", NULL);
1115
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1117
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1119
is_early_node_valid = AXIS2_TRUE;
1123
text_value = axiom_element_get_text(current_element, env, current_node);
1124
if(text_value != NULL)
1126
status = adb_ncDescribeResourceResponseType_set_diskSizeAvailable(_ncDescribeResourceResponseType, env,
1132
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element diskSizeAvailable");
1133
status = AXIS2_FAILURE;
1136
if(AXIS2_FAILURE == status)
1138
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for diskSizeAvailable ");
1141
axutil_qname_free(element_qname, env);
1143
return AXIS2_FAILURE;
1147
else if(!dont_care_minoccurs)
1151
axutil_qname_free(element_qname, env);
1153
/* this is not a nillable element*/
1154
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element diskSizeAvailable missing");
1155
return AXIS2_FAILURE;
1160
axutil_qname_free(element_qname, env);
1161
element_qname = NULL;
1167
* building numberOfCoresMax element
1173
* because elements are ordered this works fine
1177
if(current_node != NULL && is_early_node_valid)
1179
current_node = axiom_node_get_next_sibling(current_node, env);
1182
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1184
current_node = axiom_node_get_next_sibling(current_node, env);
1186
if(current_node != NULL)
1188
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1189
qname = axiom_element_get_qname(current_element, env, current_node);
1193
is_early_node_valid = AXIS2_FALSE;
1195
element_qname = axutil_qname_create(env, "numberOfCoresMax", "http://eucalyptus.ucsb.edu/", NULL);
1199
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1201
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1203
is_early_node_valid = AXIS2_TRUE;
1207
text_value = axiom_element_get_text(current_element, env, current_node);
1208
if(text_value != NULL)
1210
status = adb_ncDescribeResourceResponseType_set_numberOfCoresMax(_ncDescribeResourceResponseType, env,
1216
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element numberOfCoresMax");
1217
status = AXIS2_FAILURE;
1220
if(AXIS2_FAILURE == status)
1222
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for numberOfCoresMax ");
1225
axutil_qname_free(element_qname, env);
1227
return AXIS2_FAILURE;
1231
else if(!dont_care_minoccurs)
1235
axutil_qname_free(element_qname, env);
1237
/* this is not a nillable element*/
1238
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element numberOfCoresMax missing");
1239
return AXIS2_FAILURE;
1244
axutil_qname_free(element_qname, env);
1245
element_qname = NULL;
1251
* building numberOfCoresAvailable element
1257
* because elements are ordered this works fine
1261
if(current_node != NULL && is_early_node_valid)
1263
current_node = axiom_node_get_next_sibling(current_node, env);
1266
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1268
current_node = axiom_node_get_next_sibling(current_node, env);
1270
if(current_node != NULL)
1272
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1273
qname = axiom_element_get_qname(current_element, env, current_node);
1277
is_early_node_valid = AXIS2_FALSE;
1279
element_qname = axutil_qname_create(env, "numberOfCoresAvailable", "http://eucalyptus.ucsb.edu/", NULL);
1283
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1285
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1287
is_early_node_valid = AXIS2_TRUE;
1291
text_value = axiom_element_get_text(current_element, env, current_node);
1292
if(text_value != NULL)
1294
status = adb_ncDescribeResourceResponseType_set_numberOfCoresAvailable(_ncDescribeResourceResponseType, env,
1300
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element numberOfCoresAvailable");
1301
status = AXIS2_FAILURE;
1304
if(AXIS2_FAILURE == status)
1306
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for numberOfCoresAvailable ");
1309
axutil_qname_free(element_qname, env);
1311
return AXIS2_FAILURE;
1315
else if(!dont_care_minoccurs)
1319
axutil_qname_free(element_qname, env);
1321
/* this is not a nillable element*/
1322
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element numberOfCoresAvailable missing");
1323
return AXIS2_FAILURE;
1328
axutil_qname_free(element_qname, env);
1329
element_qname = NULL;
1335
* building publicSubnets element
1341
* because elements are ordered this works fine
1345
if(current_node != NULL && is_early_node_valid)
1347
current_node = axiom_node_get_next_sibling(current_node, env);
1350
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1352
current_node = axiom_node_get_next_sibling(current_node, env);
1354
if(current_node != NULL)
1356
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1357
qname = axiom_element_get_qname(current_element, env, current_node);
1361
is_early_node_valid = AXIS2_FALSE;
1363
element_qname = axutil_qname_create(env, "publicSubnets", "http://eucalyptus.ucsb.edu/", NULL);
1367
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1369
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1371
is_early_node_valid = AXIS2_TRUE;
1375
text_value = axiom_element_get_text(current_element, env, current_node);
1376
if(text_value != NULL)
1378
status = adb_ncDescribeResourceResponseType_set_publicSubnets(_ncDescribeResourceResponseType, env,
1385
* axis2_qname_t *qname = NULL;
1386
* axiom_attribute_t *the_attri = NULL;
1388
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1389
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1391
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1393
axiom_attribute_t *the_attri = NULL;
1394
axis2_char_t *attrib_text = NULL;
1395
axutil_hash_t *attribute_hash = NULL;
1397
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1402
axutil_hash_index_t *hi;
1406
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1408
axutil_hash_this(hi, &key, NULL, &val);
1410
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1412
the_attri = (axiom_attribute_t*)val;
1420
attrib_text = axiom_attribute_get_value(the_attri, env);
1424
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1425
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1428
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1430
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element publicSubnets");
1431
status = AXIS2_FAILURE;
1435
/* after all, we found this is a empty string */
1436
status = adb_ncDescribeResourceResponseType_set_publicSubnets(_ncDescribeResourceResponseType, env,
1441
if(AXIS2_FAILURE == status)
1443
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for publicSubnets ");
1446
axutil_qname_free(element_qname, env);
1448
return AXIS2_FAILURE;
1452
else if(!dont_care_minoccurs)
1456
axutil_qname_free(element_qname, env);
1458
/* this is not a nillable element*/
1459
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element publicSubnets missing");
1460
return AXIS2_FAILURE;
1465
axutil_qname_free(element_qname, env);
1466
element_qname = NULL;
1472
axis2_bool_t AXIS2_CALL
1473
adb_ncDescribeResourceResponseType_is_particle()
1482
adb_ncDescribeResourceResponseType_declare_parent_namespaces(
1483
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
1484
const axutil_env_t *env, axiom_element_t *parent_element,
1485
axutil_hash_t *namespaces, int *next_ns_index)
1488
/* Here this is an empty function, Nothing to declare */
1494
axiom_node_t* AXIS2_CALL
1495
adb_ncDescribeResourceResponseType_serialize(
1496
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
1497
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)
1501
axis2_char_t *string_to_stream;
1504
axiom_node_t *current_node = NULL;
1509
axiom_namespace_t *ns1 = NULL;
1511
axis2_char_t *qname_uri = NULL;
1512
axis2_char_t *qname_prefix = NULL;
1513
axis2_char_t *p_prefix = NULL;
1514
axis2_bool_t ns_already_defined;
1516
axis2_char_t *text_value_1;
1517
axis2_char_t *text_value_1_temp;
1519
axis2_char_t *text_value_2;
1520
axis2_char_t *text_value_2_temp;
1522
axis2_char_t text_value_3[64];
1524
axis2_char_t *text_value_4;
1525
axis2_char_t *text_value_4_temp;
1527
axis2_char_t text_value_5[64];
1529
axis2_char_t *text_value_6;
1530
axis2_char_t *text_value_6_temp;
1532
axis2_char_t text_value_7[64];
1534
axis2_char_t text_value_8[64];
1536
axis2_char_t text_value_9[64];
1538
axis2_char_t text_value_10[64];
1540
axis2_char_t text_value_11[64];
1542
axis2_char_t text_value_12[64];
1544
axis2_char_t *text_value_13;
1545
axis2_char_t *text_value_13_temp;
1547
axis2_char_t *start_input_str = NULL;
1548
axis2_char_t *end_input_str = NULL;
1549
unsigned int start_input_str_len = 0;
1550
unsigned int end_input_str_len = 0;
1553
axiom_data_source_t *data_source = NULL;
1554
axutil_stream_t *stream = NULL;
1558
AXIS2_ENV_CHECK(env, NULL);
1559
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
1562
current_node = parent;
1563
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1566
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1570
if(!parent_tag_closed)
1573
string_to_stream = ">";
1574
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1579
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1581
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1582
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1583
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1585
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1586
"http://eucalyptus.ucsb.edu/",
1591
if (!_ncDescribeResourceResponseType->is_valid_correlationId)
1594
/* no need to complain for minoccurs=0 element */
1600
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1601
(4 + axutil_strlen(p_prefix) +
1602
axutil_strlen("correlationId")));
1604
/* axutil_strlen("<:>") + 1 = 4 */
1605
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1606
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1607
/* axutil_strlen("</:>") + 1 = 5 */
1615
* parsing correlationId element
1620
sprintf(start_input_str, "<%s%scorrelationId>",
1621
p_prefix?p_prefix:"",
1622
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1624
start_input_str_len = axutil_strlen(start_input_str);
1625
sprintf(end_input_str, "</%s%scorrelationId>",
1626
p_prefix?p_prefix:"",
1627
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1628
end_input_str_len = axutil_strlen(end_input_str);
1630
text_value_1 = _ncDescribeResourceResponseType->property_correlationId;
1632
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1635
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1636
if (text_value_1_temp)
1638
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1639
AXIS2_FREE(env->allocator, text_value_1_temp);
1643
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1646
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1649
AXIS2_FREE(env->allocator,start_input_str);
1650
AXIS2_FREE(env->allocator,end_input_str);
1654
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1656
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1657
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1658
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1660
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1661
"http://eucalyptus.ucsb.edu/",
1666
if (!_ncDescribeResourceResponseType->is_valid_userId)
1669
/* no need to complain for minoccurs=0 element */
1675
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1676
(4 + axutil_strlen(p_prefix) +
1677
axutil_strlen("userId")));
1679
/* axutil_strlen("<:>") + 1 = 4 */
1680
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1681
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1682
/* axutil_strlen("</:>") + 1 = 5 */
1690
* parsing userId element
1695
sprintf(start_input_str, "<%s%suserId>",
1696
p_prefix?p_prefix:"",
1697
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1699
start_input_str_len = axutil_strlen(start_input_str);
1700
sprintf(end_input_str, "</%s%suserId>",
1701
p_prefix?p_prefix:"",
1702
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1703
end_input_str_len = axutil_strlen(end_input_str);
1705
text_value_2 = _ncDescribeResourceResponseType->property_userId;
1707
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1710
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1711
if (text_value_2_temp)
1713
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1714
AXIS2_FREE(env->allocator, text_value_2_temp);
1718
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1721
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1724
AXIS2_FREE(env->allocator,start_input_str);
1725
AXIS2_FREE(env->allocator,end_input_str);
1729
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1731
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1732
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1733
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1735
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1736
"http://eucalyptus.ucsb.edu/",
1741
if (!_ncDescribeResourceResponseType->is_valid_return)
1744
/* no need to complain for minoccurs=0 element */
1750
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1751
(4 + axutil_strlen(p_prefix) +
1752
axutil_strlen("return")));
1754
/* axutil_strlen("<:>") + 1 = 4 */
1755
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1756
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1757
/* axutil_strlen("</:>") + 1 = 5 */
1765
* parsing return element
1770
sprintf(start_input_str, "<%s%sreturn>",
1771
p_prefix?p_prefix:"",
1772
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1774
start_input_str_len = axutil_strlen(start_input_str);
1775
sprintf(end_input_str, "</%s%sreturn>",
1776
p_prefix?p_prefix:"",
1777
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1778
end_input_str_len = axutil_strlen(end_input_str);
1780
strcpy(text_value_3, (_ncDescribeResourceResponseType->property_return)?"true":"false");
1782
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1784
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1786
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1789
AXIS2_FREE(env->allocator,start_input_str);
1790
AXIS2_FREE(env->allocator,end_input_str);
1794
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1796
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1797
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1798
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1800
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1801
"http://eucalyptus.ucsb.edu/",
1806
if (!_ncDescribeResourceResponseType->is_valid_nodeName)
1809
/* no need to complain for minoccurs=0 element */
1815
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1816
(4 + axutil_strlen(p_prefix) +
1817
axutil_strlen("nodeName")));
1819
/* axutil_strlen("<:>") + 1 = 4 */
1820
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1821
(5 + axutil_strlen(p_prefix) + axutil_strlen("nodeName")));
1822
/* axutil_strlen("</:>") + 1 = 5 */
1830
* parsing nodeName element
1835
sprintf(start_input_str, "<%s%snodeName>",
1836
p_prefix?p_prefix:"",
1837
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1839
start_input_str_len = axutil_strlen(start_input_str);
1840
sprintf(end_input_str, "</%s%snodeName>",
1841
p_prefix?p_prefix:"",
1842
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1843
end_input_str_len = axutil_strlen(end_input_str);
1845
text_value_4 = _ncDescribeResourceResponseType->property_nodeName;
1847
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1850
text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
1851
if (text_value_4_temp)
1853
axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
1854
AXIS2_FREE(env->allocator, text_value_4_temp);
1858
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1861
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1864
AXIS2_FREE(env->allocator,start_input_str);
1865
AXIS2_FREE(env->allocator,end_input_str);
1869
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1871
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1872
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1873
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1875
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1876
"http://eucalyptus.ucsb.edu/",
1881
if (!_ncDescribeResourceResponseType->is_valid_statusMessage)
1884
/* no need to complain for minoccurs=0 element */
1890
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1891
(4 + axutil_strlen(p_prefix) +
1892
axutil_strlen("statusMessage")));
1894
/* axutil_strlen("<:>") + 1 = 4 */
1895
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1896
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1897
/* axutil_strlen("</:>") + 1 = 5 */
1905
* parsing statusMessage element
1910
sprintf(start_input_str, "<%s%sstatusMessage>",
1911
p_prefix?p_prefix:"",
1912
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1914
start_input_str_len = axutil_strlen(start_input_str);
1915
sprintf(end_input_str, "</%s%sstatusMessage>",
1916
p_prefix?p_prefix:"",
1917
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1918
end_input_str_len = axutil_strlen(end_input_str);
1920
sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_statusMessage);
1922
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1924
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1926
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1929
AXIS2_FREE(env->allocator,start_input_str);
1930
AXIS2_FREE(env->allocator,end_input_str);
1934
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1936
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1937
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1938
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1940
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1941
"http://eucalyptus.ucsb.edu/",
1946
if (!_ncDescribeResourceResponseType->is_valid_nodeStatus)
1950
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property nodeStatus");
1956
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1957
(4 + axutil_strlen(p_prefix) +
1958
axutil_strlen("nodeStatus")));
1960
/* axutil_strlen("<:>") + 1 = 4 */
1961
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1962
(5 + axutil_strlen(p_prefix) + axutil_strlen("nodeStatus")));
1963
/* axutil_strlen("</:>") + 1 = 5 */
1971
* parsing nodeStatus element
1976
sprintf(start_input_str, "<%s%snodeStatus>",
1977
p_prefix?p_prefix:"",
1978
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1980
start_input_str_len = axutil_strlen(start_input_str);
1981
sprintf(end_input_str, "</%s%snodeStatus>",
1982
p_prefix?p_prefix:"",
1983
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1984
end_input_str_len = axutil_strlen(end_input_str);
1986
text_value_6 = _ncDescribeResourceResponseType->property_nodeStatus;
1988
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1991
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1992
if (text_value_6_temp)
1994
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1995
AXIS2_FREE(env->allocator, text_value_6_temp);
1999
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
2002
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2005
AXIS2_FREE(env->allocator,start_input_str);
2006
AXIS2_FREE(env->allocator,end_input_str);
2010
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2012
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2013
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2014
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2016
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2017
"http://eucalyptus.ucsb.edu/",
2022
if (!_ncDescribeResourceResponseType->is_valid_memorySizeMax)
2026
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property memorySizeMax");
2032
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2033
(4 + axutil_strlen(p_prefix) +
2034
axutil_strlen("memorySizeMax")));
2036
/* axutil_strlen("<:>") + 1 = 4 */
2037
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2038
(5 + axutil_strlen(p_prefix) + axutil_strlen("memorySizeMax")));
2039
/* axutil_strlen("</:>") + 1 = 5 */
2047
* parsing memorySizeMax element
2052
sprintf(start_input_str, "<%s%smemorySizeMax>",
2053
p_prefix?p_prefix:"",
2054
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2056
start_input_str_len = axutil_strlen(start_input_str);
2057
sprintf(end_input_str, "</%s%smemorySizeMax>",
2058
p_prefix?p_prefix:"",
2059
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2060
end_input_str_len = axutil_strlen(end_input_str);
2062
sprintf (text_value_7, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_memorySizeMax);
2064
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2066
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
2068
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2071
AXIS2_FREE(env->allocator,start_input_str);
2072
AXIS2_FREE(env->allocator,end_input_str);
2076
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2078
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2079
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2080
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2082
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2083
"http://eucalyptus.ucsb.edu/",
2088
if (!_ncDescribeResourceResponseType->is_valid_memorySizeAvailable)
2092
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property memorySizeAvailable");
2098
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2099
(4 + axutil_strlen(p_prefix) +
2100
axutil_strlen("memorySizeAvailable")));
2102
/* axutil_strlen("<:>") + 1 = 4 */
2103
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2104
(5 + axutil_strlen(p_prefix) + axutil_strlen("memorySizeAvailable")));
2105
/* axutil_strlen("</:>") + 1 = 5 */
2113
* parsing memorySizeAvailable element
2118
sprintf(start_input_str, "<%s%smemorySizeAvailable>",
2119
p_prefix?p_prefix:"",
2120
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2122
start_input_str_len = axutil_strlen(start_input_str);
2123
sprintf(end_input_str, "</%s%smemorySizeAvailable>",
2124
p_prefix?p_prefix:"",
2125
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2126
end_input_str_len = axutil_strlen(end_input_str);
2128
sprintf (text_value_8, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_memorySizeAvailable);
2130
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2132
axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
2134
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2137
AXIS2_FREE(env->allocator,start_input_str);
2138
AXIS2_FREE(env->allocator,end_input_str);
2142
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2144
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2145
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2146
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2148
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2149
"http://eucalyptus.ucsb.edu/",
2154
if (!_ncDescribeResourceResponseType->is_valid_diskSizeMax)
2158
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property diskSizeMax");
2164
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2165
(4 + axutil_strlen(p_prefix) +
2166
axutil_strlen("diskSizeMax")));
2168
/* axutil_strlen("<:>") + 1 = 4 */
2169
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2170
(5 + axutil_strlen(p_prefix) + axutil_strlen("diskSizeMax")));
2171
/* axutil_strlen("</:>") + 1 = 5 */
2179
* parsing diskSizeMax element
2184
sprintf(start_input_str, "<%s%sdiskSizeMax>",
2185
p_prefix?p_prefix:"",
2186
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2188
start_input_str_len = axutil_strlen(start_input_str);
2189
sprintf(end_input_str, "</%s%sdiskSizeMax>",
2190
p_prefix?p_prefix:"",
2191
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2192
end_input_str_len = axutil_strlen(end_input_str);
2194
sprintf (text_value_9, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_diskSizeMax);
2196
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2198
axutil_stream_write(stream, env, text_value_9, axutil_strlen(text_value_9));
2200
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2203
AXIS2_FREE(env->allocator,start_input_str);
2204
AXIS2_FREE(env->allocator,end_input_str);
2208
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2210
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2211
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2212
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2214
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2215
"http://eucalyptus.ucsb.edu/",
2220
if (!_ncDescribeResourceResponseType->is_valid_diskSizeAvailable)
2224
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property diskSizeAvailable");
2230
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2231
(4 + axutil_strlen(p_prefix) +
2232
axutil_strlen("diskSizeAvailable")));
2234
/* axutil_strlen("<:>") + 1 = 4 */
2235
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2236
(5 + axutil_strlen(p_prefix) + axutil_strlen("diskSizeAvailable")));
2237
/* axutil_strlen("</:>") + 1 = 5 */
2245
* parsing diskSizeAvailable element
2250
sprintf(start_input_str, "<%s%sdiskSizeAvailable>",
2251
p_prefix?p_prefix:"",
2252
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2254
start_input_str_len = axutil_strlen(start_input_str);
2255
sprintf(end_input_str, "</%s%sdiskSizeAvailable>",
2256
p_prefix?p_prefix:"",
2257
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2258
end_input_str_len = axutil_strlen(end_input_str);
2260
sprintf (text_value_10, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_diskSizeAvailable);
2262
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2264
axutil_stream_write(stream, env, text_value_10, axutil_strlen(text_value_10));
2266
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2269
AXIS2_FREE(env->allocator,start_input_str);
2270
AXIS2_FREE(env->allocator,end_input_str);
2274
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2276
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2277
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2278
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2280
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2281
"http://eucalyptus.ucsb.edu/",
2286
if (!_ncDescribeResourceResponseType->is_valid_numberOfCoresMax)
2290
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property numberOfCoresMax");
2296
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2297
(4 + axutil_strlen(p_prefix) +
2298
axutil_strlen("numberOfCoresMax")));
2300
/* axutil_strlen("<:>") + 1 = 4 */
2301
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2302
(5 + axutil_strlen(p_prefix) + axutil_strlen("numberOfCoresMax")));
2303
/* axutil_strlen("</:>") + 1 = 5 */
2311
* parsing numberOfCoresMax element
2316
sprintf(start_input_str, "<%s%snumberOfCoresMax>",
2317
p_prefix?p_prefix:"",
2318
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2320
start_input_str_len = axutil_strlen(start_input_str);
2321
sprintf(end_input_str, "</%s%snumberOfCoresMax>",
2322
p_prefix?p_prefix:"",
2323
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2324
end_input_str_len = axutil_strlen(end_input_str);
2326
sprintf (text_value_11, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_numberOfCoresMax);
2328
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2330
axutil_stream_write(stream, env, text_value_11, axutil_strlen(text_value_11));
2332
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2335
AXIS2_FREE(env->allocator,start_input_str);
2336
AXIS2_FREE(env->allocator,end_input_str);
2340
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2342
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2343
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2344
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2346
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2347
"http://eucalyptus.ucsb.edu/",
2352
if (!_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable)
2356
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property numberOfCoresAvailable");
2362
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2363
(4 + axutil_strlen(p_prefix) +
2364
axutil_strlen("numberOfCoresAvailable")));
2366
/* axutil_strlen("<:>") + 1 = 4 */
2367
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2368
(5 + axutil_strlen(p_prefix) + axutil_strlen("numberOfCoresAvailable")));
2369
/* axutil_strlen("</:>") + 1 = 5 */
2377
* parsing numberOfCoresAvailable element
2382
sprintf(start_input_str, "<%s%snumberOfCoresAvailable>",
2383
p_prefix?p_prefix:"",
2384
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2386
start_input_str_len = axutil_strlen(start_input_str);
2387
sprintf(end_input_str, "</%s%snumberOfCoresAvailable>",
2388
p_prefix?p_prefix:"",
2389
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2390
end_input_str_len = axutil_strlen(end_input_str);
2392
sprintf (text_value_12, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_numberOfCoresAvailable);
2394
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2396
axutil_stream_write(stream, env, text_value_12, axutil_strlen(text_value_12));
2398
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2401
AXIS2_FREE(env->allocator,start_input_str);
2402
AXIS2_FREE(env->allocator,end_input_str);
2406
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2408
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2409
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2410
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2412
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2413
"http://eucalyptus.ucsb.edu/",
2418
if (!_ncDescribeResourceResponseType->is_valid_publicSubnets)
2422
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property publicSubnets");
2428
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2429
(4 + axutil_strlen(p_prefix) +
2430
axutil_strlen("publicSubnets")));
2432
/* axutil_strlen("<:>") + 1 = 4 */
2433
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2434
(5 + axutil_strlen(p_prefix) + axutil_strlen("publicSubnets")));
2435
/* axutil_strlen("</:>") + 1 = 5 */
2443
* parsing publicSubnets element
2448
sprintf(start_input_str, "<%s%spublicSubnets>",
2449
p_prefix?p_prefix:"",
2450
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2452
start_input_str_len = axutil_strlen(start_input_str);
2453
sprintf(end_input_str, "</%s%spublicSubnets>",
2454
p_prefix?p_prefix:"",
2455
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2456
end_input_str_len = axutil_strlen(end_input_str);
2458
text_value_13 = _ncDescribeResourceResponseType->property_publicSubnets;
2460
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2463
text_value_13_temp = axutil_xml_quote_string(env, text_value_13, AXIS2_TRUE);
2464
if (text_value_13_temp)
2466
axutil_stream_write(stream, env, text_value_13_temp, axutil_strlen(text_value_13_temp));
2467
AXIS2_FREE(env->allocator, text_value_13_temp);
2471
axutil_stream_write(stream, env, text_value_13, axutil_strlen(text_value_13));
2474
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2477
AXIS2_FREE(env->allocator,start_input_str);
2478
AXIS2_FREE(env->allocator,end_input_str);
2490
* getter for correlationId.
2492
axis2_char_t* AXIS2_CALL
2493
adb_ncDescribeResourceResponseType_get_correlationId(
2494
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2495
const axutil_env_t *env)
2498
AXIS2_ENV_CHECK(env, NULL);
2499
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
2502
return _ncDescribeResourceResponseType->property_correlationId;
2506
* setter for correlationId
2508
axis2_status_t AXIS2_CALL
2509
adb_ncDescribeResourceResponseType_set_correlationId(
2510
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2511
const axutil_env_t *env,
2512
const axis2_char_t* arg_correlationId)
2516
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2517
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2519
if(_ncDescribeResourceResponseType->is_valid_correlationId &&
2520
arg_correlationId == _ncDescribeResourceResponseType->property_correlationId)
2523
return AXIS2_SUCCESS;
2526
adb_ncDescribeResourceResponseType_reset_correlationId(_ncDescribeResourceResponseType, env);
2529
if(NULL == arg_correlationId)
2531
/* We are already done */
2532
return AXIS2_SUCCESS;
2534
_ncDescribeResourceResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
2535
if(NULL == _ncDescribeResourceResponseType->property_correlationId)
2537
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
2538
return AXIS2_FAILURE;
2540
_ncDescribeResourceResponseType->is_valid_correlationId = AXIS2_TRUE;
2542
return AXIS2_SUCCESS;
2548
* resetter for correlationId
2550
axis2_status_t AXIS2_CALL
2551
adb_ncDescribeResourceResponseType_reset_correlationId(
2552
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2553
const axutil_env_t *env)
2557
void *element = NULL;
2559
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2560
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2566
if(_ncDescribeResourceResponseType->property_correlationId != NULL)
2570
AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_correlationId);
2571
_ncDescribeResourceResponseType->property_correlationId = NULL;
2576
_ncDescribeResourceResponseType->is_valid_correlationId = AXIS2_FALSE;
2577
return AXIS2_SUCCESS;
2581
* Check whether correlationId is nill
2583
axis2_bool_t AXIS2_CALL
2584
adb_ncDescribeResourceResponseType_is_correlationId_nil(
2585
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2586
const axutil_env_t *env)
2588
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2589
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2591
return !_ncDescribeResourceResponseType->is_valid_correlationId;
2595
* Set correlationId to nill (currently the same as reset)
2597
axis2_status_t AXIS2_CALL
2598
adb_ncDescribeResourceResponseType_set_correlationId_nil(
2599
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2600
const axutil_env_t *env)
2602
return adb_ncDescribeResourceResponseType_reset_correlationId(_ncDescribeResourceResponseType, env);
2608
* getter for userId.
2610
axis2_char_t* AXIS2_CALL
2611
adb_ncDescribeResourceResponseType_get_userId(
2612
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2613
const axutil_env_t *env)
2616
AXIS2_ENV_CHECK(env, NULL);
2617
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
2620
return _ncDescribeResourceResponseType->property_userId;
2626
axis2_status_t AXIS2_CALL
2627
adb_ncDescribeResourceResponseType_set_userId(
2628
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2629
const axutil_env_t *env,
2630
const axis2_char_t* arg_userId)
2634
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2635
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2637
if(_ncDescribeResourceResponseType->is_valid_userId &&
2638
arg_userId == _ncDescribeResourceResponseType->property_userId)
2641
return AXIS2_SUCCESS;
2644
adb_ncDescribeResourceResponseType_reset_userId(_ncDescribeResourceResponseType, env);
2647
if(NULL == arg_userId)
2649
/* We are already done */
2650
return AXIS2_SUCCESS;
2652
_ncDescribeResourceResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
2653
if(NULL == _ncDescribeResourceResponseType->property_userId)
2655
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
2656
return AXIS2_FAILURE;
2658
_ncDescribeResourceResponseType->is_valid_userId = AXIS2_TRUE;
2660
return AXIS2_SUCCESS;
2666
* resetter for userId
2668
axis2_status_t AXIS2_CALL
2669
adb_ncDescribeResourceResponseType_reset_userId(
2670
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2671
const axutil_env_t *env)
2675
void *element = NULL;
2677
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2678
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2684
if(_ncDescribeResourceResponseType->property_userId != NULL)
2688
AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_userId);
2689
_ncDescribeResourceResponseType->property_userId = NULL;
2694
_ncDescribeResourceResponseType->is_valid_userId = AXIS2_FALSE;
2695
return AXIS2_SUCCESS;
2699
* Check whether userId is nill
2701
axis2_bool_t AXIS2_CALL
2702
adb_ncDescribeResourceResponseType_is_userId_nil(
2703
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2704
const axutil_env_t *env)
2706
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2707
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2709
return !_ncDescribeResourceResponseType->is_valid_userId;
2713
* Set userId to nill (currently the same as reset)
2715
axis2_status_t AXIS2_CALL
2716
adb_ncDescribeResourceResponseType_set_userId_nil(
2717
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2718
const axutil_env_t *env)
2720
return adb_ncDescribeResourceResponseType_reset_userId(_ncDescribeResourceResponseType, env);
2726
* getter for return.
2728
axis2_bool_t AXIS2_CALL
2729
adb_ncDescribeResourceResponseType_get_return(
2730
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2731
const axutil_env_t *env)
2734
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
2735
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (axis2_bool_t)0);
2738
return _ncDescribeResourceResponseType->property_return;
2744
axis2_status_t AXIS2_CALL
2745
adb_ncDescribeResourceResponseType_set_return(
2746
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2747
const axutil_env_t *env,
2748
axis2_bool_t arg_return)
2752
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2753
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2755
if(_ncDescribeResourceResponseType->is_valid_return &&
2756
arg_return == _ncDescribeResourceResponseType->property_return)
2759
return AXIS2_SUCCESS;
2762
adb_ncDescribeResourceResponseType_reset_return(_ncDescribeResourceResponseType, env);
2764
_ncDescribeResourceResponseType->property_return = arg_return;
2765
_ncDescribeResourceResponseType->is_valid_return = AXIS2_TRUE;
2767
return AXIS2_SUCCESS;
2773
* resetter for return
2775
axis2_status_t AXIS2_CALL
2776
adb_ncDescribeResourceResponseType_reset_return(
2777
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2778
const axutil_env_t *env)
2782
void *element = NULL;
2784
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2785
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2788
_ncDescribeResourceResponseType->is_valid_return = AXIS2_FALSE;
2789
return AXIS2_SUCCESS;
2793
* Check whether return is nill
2795
axis2_bool_t AXIS2_CALL
2796
adb_ncDescribeResourceResponseType_is_return_nil(
2797
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2798
const axutil_env_t *env)
2800
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2801
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2803
return !_ncDescribeResourceResponseType->is_valid_return;
2807
* Set return to nill (currently the same as reset)
2809
axis2_status_t AXIS2_CALL
2810
adb_ncDescribeResourceResponseType_set_return_nil(
2811
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2812
const axutil_env_t *env)
2814
return adb_ncDescribeResourceResponseType_reset_return(_ncDescribeResourceResponseType, env);
2820
* getter for nodeName.
2822
axis2_char_t* AXIS2_CALL
2823
adb_ncDescribeResourceResponseType_get_nodeName(
2824
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2825
const axutil_env_t *env)
2828
AXIS2_ENV_CHECK(env, NULL);
2829
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
2832
return _ncDescribeResourceResponseType->property_nodeName;
2836
* setter for nodeName
2838
axis2_status_t AXIS2_CALL
2839
adb_ncDescribeResourceResponseType_set_nodeName(
2840
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2841
const axutil_env_t *env,
2842
const axis2_char_t* arg_nodeName)
2846
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2847
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2849
if(_ncDescribeResourceResponseType->is_valid_nodeName &&
2850
arg_nodeName == _ncDescribeResourceResponseType->property_nodeName)
2853
return AXIS2_SUCCESS;
2856
adb_ncDescribeResourceResponseType_reset_nodeName(_ncDescribeResourceResponseType, env);
2859
if(NULL == arg_nodeName)
2861
/* We are already done */
2862
return AXIS2_SUCCESS;
2864
_ncDescribeResourceResponseType->property_nodeName = (axis2_char_t *)axutil_strdup(env, arg_nodeName);
2865
if(NULL == _ncDescribeResourceResponseType->property_nodeName)
2867
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeName");
2868
return AXIS2_FAILURE;
2870
_ncDescribeResourceResponseType->is_valid_nodeName = AXIS2_TRUE;
2872
return AXIS2_SUCCESS;
2878
* resetter for nodeName
2880
axis2_status_t AXIS2_CALL
2881
adb_ncDescribeResourceResponseType_reset_nodeName(
2882
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2883
const axutil_env_t *env)
2887
void *element = NULL;
2889
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2890
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2896
if(_ncDescribeResourceResponseType->property_nodeName != NULL)
2900
AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_nodeName);
2901
_ncDescribeResourceResponseType->property_nodeName = NULL;
2906
_ncDescribeResourceResponseType->is_valid_nodeName = AXIS2_FALSE;
2907
return AXIS2_SUCCESS;
2911
* Check whether nodeName is nill
2913
axis2_bool_t AXIS2_CALL
2914
adb_ncDescribeResourceResponseType_is_nodeName_nil(
2915
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2916
const axutil_env_t *env)
2918
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2919
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2921
return !_ncDescribeResourceResponseType->is_valid_nodeName;
2925
* Set nodeName to nill (currently the same as reset)
2927
axis2_status_t AXIS2_CALL
2928
adb_ncDescribeResourceResponseType_set_nodeName_nil(
2929
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2930
const axutil_env_t *env)
2932
return adb_ncDescribeResourceResponseType_reset_nodeName(_ncDescribeResourceResponseType, env);
2938
* getter for statusMessage.
2941
adb_ncDescribeResourceResponseType_get_statusMessage(
2942
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2943
const axutil_env_t *env)
2946
AXIS2_ENV_CHECK(env, (int)0);
2947
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
2950
return _ncDescribeResourceResponseType->property_statusMessage;
2954
* setter for statusMessage
2956
axis2_status_t AXIS2_CALL
2957
adb_ncDescribeResourceResponseType_set_statusMessage(
2958
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2959
const axutil_env_t *env,
2960
const int arg_statusMessage)
2964
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2965
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2967
if(_ncDescribeResourceResponseType->is_valid_statusMessage &&
2968
arg_statusMessage == _ncDescribeResourceResponseType->property_statusMessage)
2971
return AXIS2_SUCCESS;
2974
adb_ncDescribeResourceResponseType_reset_statusMessage(_ncDescribeResourceResponseType, env);
2976
_ncDescribeResourceResponseType->property_statusMessage = arg_statusMessage;
2977
_ncDescribeResourceResponseType->is_valid_statusMessage = AXIS2_TRUE;
2979
return AXIS2_SUCCESS;
2985
* resetter for statusMessage
2987
axis2_status_t AXIS2_CALL
2988
adb_ncDescribeResourceResponseType_reset_statusMessage(
2989
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2990
const axutil_env_t *env)
2994
void *element = NULL;
2996
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2997
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3000
_ncDescribeResourceResponseType->is_valid_statusMessage = AXIS2_FALSE;
3001
return AXIS2_SUCCESS;
3005
* Check whether statusMessage is nill
3007
axis2_bool_t AXIS2_CALL
3008
adb_ncDescribeResourceResponseType_is_statusMessage_nil(
3009
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3010
const axutil_env_t *env)
3012
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3013
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3015
return !_ncDescribeResourceResponseType->is_valid_statusMessage;
3019
* Set statusMessage to nill (currently the same as reset)
3021
axis2_status_t AXIS2_CALL
3022
adb_ncDescribeResourceResponseType_set_statusMessage_nil(
3023
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3024
const axutil_env_t *env)
3026
return adb_ncDescribeResourceResponseType_reset_statusMessage(_ncDescribeResourceResponseType, env);
3032
* getter for nodeStatus.
3034
axis2_char_t* AXIS2_CALL
3035
adb_ncDescribeResourceResponseType_get_nodeStatus(
3036
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3037
const axutil_env_t *env)
3040
AXIS2_ENV_CHECK(env, NULL);
3041
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
3044
return _ncDescribeResourceResponseType->property_nodeStatus;
3048
* setter for nodeStatus
3050
axis2_status_t AXIS2_CALL
3051
adb_ncDescribeResourceResponseType_set_nodeStatus(
3052
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3053
const axutil_env_t *env,
3054
const axis2_char_t* arg_nodeStatus)
3058
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3059
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3061
if(_ncDescribeResourceResponseType->is_valid_nodeStatus &&
3062
arg_nodeStatus == _ncDescribeResourceResponseType->property_nodeStatus)
3065
return AXIS2_SUCCESS;
3069
if(NULL == arg_nodeStatus)
3071
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "nodeStatus is being set to NULL, but it is not a nullable element");
3072
return AXIS2_FAILURE;
3074
adb_ncDescribeResourceResponseType_reset_nodeStatus(_ncDescribeResourceResponseType, env);
3077
if(NULL == arg_nodeStatus)
3079
/* We are already done */
3080
return AXIS2_SUCCESS;
3082
_ncDescribeResourceResponseType->property_nodeStatus = (axis2_char_t *)axutil_strdup(env, arg_nodeStatus);
3083
if(NULL == _ncDescribeResourceResponseType->property_nodeStatus)
3085
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeStatus");
3086
return AXIS2_FAILURE;
3088
_ncDescribeResourceResponseType->is_valid_nodeStatus = AXIS2_TRUE;
3090
return AXIS2_SUCCESS;
3096
* resetter for nodeStatus
3098
axis2_status_t AXIS2_CALL
3099
adb_ncDescribeResourceResponseType_reset_nodeStatus(
3100
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3101
const axutil_env_t *env)
3105
void *element = NULL;
3107
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3108
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3114
if(_ncDescribeResourceResponseType->property_nodeStatus != NULL)
3118
AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_nodeStatus);
3119
_ncDescribeResourceResponseType->property_nodeStatus = NULL;
3124
_ncDescribeResourceResponseType->is_valid_nodeStatus = AXIS2_FALSE;
3125
return AXIS2_SUCCESS;
3129
* Check whether nodeStatus is nill
3131
axis2_bool_t AXIS2_CALL
3132
adb_ncDescribeResourceResponseType_is_nodeStatus_nil(
3133
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3134
const axutil_env_t *env)
3136
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3137
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3139
return !_ncDescribeResourceResponseType->is_valid_nodeStatus;
3143
* Set nodeStatus to nill (currently the same as reset)
3145
axis2_status_t AXIS2_CALL
3146
adb_ncDescribeResourceResponseType_set_nodeStatus_nil(
3147
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3148
const axutil_env_t *env)
3150
return adb_ncDescribeResourceResponseType_reset_nodeStatus(_ncDescribeResourceResponseType, env);
3156
* getter for memorySizeMax.
3159
adb_ncDescribeResourceResponseType_get_memorySizeMax(
3160
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3161
const axutil_env_t *env)
3164
AXIS2_ENV_CHECK(env, (int)0);
3165
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3168
return _ncDescribeResourceResponseType->property_memorySizeMax;
3172
* setter for memorySizeMax
3174
axis2_status_t AXIS2_CALL
3175
adb_ncDescribeResourceResponseType_set_memorySizeMax(
3176
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3177
const axutil_env_t *env,
3178
const int arg_memorySizeMax)
3182
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3183
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3185
if(_ncDescribeResourceResponseType->is_valid_memorySizeMax &&
3186
arg_memorySizeMax == _ncDescribeResourceResponseType->property_memorySizeMax)
3189
return AXIS2_SUCCESS;
3192
adb_ncDescribeResourceResponseType_reset_memorySizeMax(_ncDescribeResourceResponseType, env);
3194
_ncDescribeResourceResponseType->property_memorySizeMax = arg_memorySizeMax;
3195
_ncDescribeResourceResponseType->is_valid_memorySizeMax = AXIS2_TRUE;
3197
return AXIS2_SUCCESS;
3203
* resetter for memorySizeMax
3205
axis2_status_t AXIS2_CALL
3206
adb_ncDescribeResourceResponseType_reset_memorySizeMax(
3207
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3208
const axutil_env_t *env)
3212
void *element = NULL;
3214
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3215
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3218
_ncDescribeResourceResponseType->is_valid_memorySizeMax = AXIS2_FALSE;
3219
return AXIS2_SUCCESS;
3223
* Check whether memorySizeMax is nill
3225
axis2_bool_t AXIS2_CALL
3226
adb_ncDescribeResourceResponseType_is_memorySizeMax_nil(
3227
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3228
const axutil_env_t *env)
3230
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3231
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3233
return !_ncDescribeResourceResponseType->is_valid_memorySizeMax;
3237
* Set memorySizeMax to nill (currently the same as reset)
3239
axis2_status_t AXIS2_CALL
3240
adb_ncDescribeResourceResponseType_set_memorySizeMax_nil(
3241
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3242
const axutil_env_t *env)
3244
return adb_ncDescribeResourceResponseType_reset_memorySizeMax(_ncDescribeResourceResponseType, env);
3250
* getter for memorySizeAvailable.
3253
adb_ncDescribeResourceResponseType_get_memorySizeAvailable(
3254
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3255
const axutil_env_t *env)
3258
AXIS2_ENV_CHECK(env, (int)0);
3259
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3262
return _ncDescribeResourceResponseType->property_memorySizeAvailable;
3266
* setter for memorySizeAvailable
3268
axis2_status_t AXIS2_CALL
3269
adb_ncDescribeResourceResponseType_set_memorySizeAvailable(
3270
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3271
const axutil_env_t *env,
3272
const int arg_memorySizeAvailable)
3276
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3277
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3279
if(_ncDescribeResourceResponseType->is_valid_memorySizeAvailable &&
3280
arg_memorySizeAvailable == _ncDescribeResourceResponseType->property_memorySizeAvailable)
3283
return AXIS2_SUCCESS;
3286
adb_ncDescribeResourceResponseType_reset_memorySizeAvailable(_ncDescribeResourceResponseType, env);
3288
_ncDescribeResourceResponseType->property_memorySizeAvailable = arg_memorySizeAvailable;
3289
_ncDescribeResourceResponseType->is_valid_memorySizeAvailable = AXIS2_TRUE;
3291
return AXIS2_SUCCESS;
3297
* resetter for memorySizeAvailable
3299
axis2_status_t AXIS2_CALL
3300
adb_ncDescribeResourceResponseType_reset_memorySizeAvailable(
3301
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3302
const axutil_env_t *env)
3306
void *element = NULL;
3308
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3309
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3312
_ncDescribeResourceResponseType->is_valid_memorySizeAvailable = AXIS2_FALSE;
3313
return AXIS2_SUCCESS;
3317
* Check whether memorySizeAvailable is nill
3319
axis2_bool_t AXIS2_CALL
3320
adb_ncDescribeResourceResponseType_is_memorySizeAvailable_nil(
3321
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3322
const axutil_env_t *env)
3324
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3325
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3327
return !_ncDescribeResourceResponseType->is_valid_memorySizeAvailable;
3331
* Set memorySizeAvailable to nill (currently the same as reset)
3333
axis2_status_t AXIS2_CALL
3334
adb_ncDescribeResourceResponseType_set_memorySizeAvailable_nil(
3335
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3336
const axutil_env_t *env)
3338
return adb_ncDescribeResourceResponseType_reset_memorySizeAvailable(_ncDescribeResourceResponseType, env);
3344
* getter for diskSizeMax.
3347
adb_ncDescribeResourceResponseType_get_diskSizeMax(
3348
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3349
const axutil_env_t *env)
3352
AXIS2_ENV_CHECK(env, (int)0);
3353
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3356
return _ncDescribeResourceResponseType->property_diskSizeMax;
3360
* setter for diskSizeMax
3362
axis2_status_t AXIS2_CALL
3363
adb_ncDescribeResourceResponseType_set_diskSizeMax(
3364
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3365
const axutil_env_t *env,
3366
const int arg_diskSizeMax)
3370
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3371
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3373
if(_ncDescribeResourceResponseType->is_valid_diskSizeMax &&
3374
arg_diskSizeMax == _ncDescribeResourceResponseType->property_diskSizeMax)
3377
return AXIS2_SUCCESS;
3380
adb_ncDescribeResourceResponseType_reset_diskSizeMax(_ncDescribeResourceResponseType, env);
3382
_ncDescribeResourceResponseType->property_diskSizeMax = arg_diskSizeMax;
3383
_ncDescribeResourceResponseType->is_valid_diskSizeMax = AXIS2_TRUE;
3385
return AXIS2_SUCCESS;
3391
* resetter for diskSizeMax
3393
axis2_status_t AXIS2_CALL
3394
adb_ncDescribeResourceResponseType_reset_diskSizeMax(
3395
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3396
const axutil_env_t *env)
3400
void *element = NULL;
3402
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3403
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3406
_ncDescribeResourceResponseType->is_valid_diskSizeMax = AXIS2_FALSE;
3407
return AXIS2_SUCCESS;
3411
* Check whether diskSizeMax is nill
3413
axis2_bool_t AXIS2_CALL
3414
adb_ncDescribeResourceResponseType_is_diskSizeMax_nil(
3415
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3416
const axutil_env_t *env)
3418
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3419
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3421
return !_ncDescribeResourceResponseType->is_valid_diskSizeMax;
3425
* Set diskSizeMax to nill (currently the same as reset)
3427
axis2_status_t AXIS2_CALL
3428
adb_ncDescribeResourceResponseType_set_diskSizeMax_nil(
3429
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3430
const axutil_env_t *env)
3432
return adb_ncDescribeResourceResponseType_reset_diskSizeMax(_ncDescribeResourceResponseType, env);
3438
* getter for diskSizeAvailable.
3441
adb_ncDescribeResourceResponseType_get_diskSizeAvailable(
3442
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3443
const axutil_env_t *env)
3446
AXIS2_ENV_CHECK(env, (int)0);
3447
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3450
return _ncDescribeResourceResponseType->property_diskSizeAvailable;
3454
* setter for diskSizeAvailable
3456
axis2_status_t AXIS2_CALL
3457
adb_ncDescribeResourceResponseType_set_diskSizeAvailable(
3458
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3459
const axutil_env_t *env,
3460
const int arg_diskSizeAvailable)
3464
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3465
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3467
if(_ncDescribeResourceResponseType->is_valid_diskSizeAvailable &&
3468
arg_diskSizeAvailable == _ncDescribeResourceResponseType->property_diskSizeAvailable)
3471
return AXIS2_SUCCESS;
3474
adb_ncDescribeResourceResponseType_reset_diskSizeAvailable(_ncDescribeResourceResponseType, env);
3476
_ncDescribeResourceResponseType->property_diskSizeAvailable = arg_diskSizeAvailable;
3477
_ncDescribeResourceResponseType->is_valid_diskSizeAvailable = AXIS2_TRUE;
3479
return AXIS2_SUCCESS;
3485
* resetter for diskSizeAvailable
3487
axis2_status_t AXIS2_CALL
3488
adb_ncDescribeResourceResponseType_reset_diskSizeAvailable(
3489
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3490
const axutil_env_t *env)
3494
void *element = NULL;
3496
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3497
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3500
_ncDescribeResourceResponseType->is_valid_diskSizeAvailable = AXIS2_FALSE;
3501
return AXIS2_SUCCESS;
3505
* Check whether diskSizeAvailable is nill
3507
axis2_bool_t AXIS2_CALL
3508
adb_ncDescribeResourceResponseType_is_diskSizeAvailable_nil(
3509
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3510
const axutil_env_t *env)
3512
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3513
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3515
return !_ncDescribeResourceResponseType->is_valid_diskSizeAvailable;
3519
* Set diskSizeAvailable to nill (currently the same as reset)
3521
axis2_status_t AXIS2_CALL
3522
adb_ncDescribeResourceResponseType_set_diskSizeAvailable_nil(
3523
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3524
const axutil_env_t *env)
3526
return adb_ncDescribeResourceResponseType_reset_diskSizeAvailable(_ncDescribeResourceResponseType, env);
3532
* getter for numberOfCoresMax.
3535
adb_ncDescribeResourceResponseType_get_numberOfCoresMax(
3536
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3537
const axutil_env_t *env)
3540
AXIS2_ENV_CHECK(env, (int)0);
3541
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3544
return _ncDescribeResourceResponseType->property_numberOfCoresMax;
3548
* setter for numberOfCoresMax
3550
axis2_status_t AXIS2_CALL
3551
adb_ncDescribeResourceResponseType_set_numberOfCoresMax(
3552
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3553
const axutil_env_t *env,
3554
const int arg_numberOfCoresMax)
3558
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3559
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3561
if(_ncDescribeResourceResponseType->is_valid_numberOfCoresMax &&
3562
arg_numberOfCoresMax == _ncDescribeResourceResponseType->property_numberOfCoresMax)
3565
return AXIS2_SUCCESS;
3568
adb_ncDescribeResourceResponseType_reset_numberOfCoresMax(_ncDescribeResourceResponseType, env);
3570
_ncDescribeResourceResponseType->property_numberOfCoresMax = arg_numberOfCoresMax;
3571
_ncDescribeResourceResponseType->is_valid_numberOfCoresMax = AXIS2_TRUE;
3573
return AXIS2_SUCCESS;
3579
* resetter for numberOfCoresMax
3581
axis2_status_t AXIS2_CALL
3582
adb_ncDescribeResourceResponseType_reset_numberOfCoresMax(
3583
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3584
const axutil_env_t *env)
3588
void *element = NULL;
3590
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3591
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3594
_ncDescribeResourceResponseType->is_valid_numberOfCoresMax = AXIS2_FALSE;
3595
return AXIS2_SUCCESS;
3599
* Check whether numberOfCoresMax is nill
3601
axis2_bool_t AXIS2_CALL
3602
adb_ncDescribeResourceResponseType_is_numberOfCoresMax_nil(
3603
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3604
const axutil_env_t *env)
3606
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3607
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3609
return !_ncDescribeResourceResponseType->is_valid_numberOfCoresMax;
3613
* Set numberOfCoresMax to nill (currently the same as reset)
3615
axis2_status_t AXIS2_CALL
3616
adb_ncDescribeResourceResponseType_set_numberOfCoresMax_nil(
3617
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3618
const axutil_env_t *env)
3620
return adb_ncDescribeResourceResponseType_reset_numberOfCoresMax(_ncDescribeResourceResponseType, env);
3626
* getter for numberOfCoresAvailable.
3629
adb_ncDescribeResourceResponseType_get_numberOfCoresAvailable(
3630
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3631
const axutil_env_t *env)
3634
AXIS2_ENV_CHECK(env, (int)0);
3635
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3638
return _ncDescribeResourceResponseType->property_numberOfCoresAvailable;
3642
* setter for numberOfCoresAvailable
3644
axis2_status_t AXIS2_CALL
3645
adb_ncDescribeResourceResponseType_set_numberOfCoresAvailable(
3646
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3647
const axutil_env_t *env,
3648
const int arg_numberOfCoresAvailable)
3652
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3653
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3655
if(_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable &&
3656
arg_numberOfCoresAvailable == _ncDescribeResourceResponseType->property_numberOfCoresAvailable)
3659
return AXIS2_SUCCESS;
3662
adb_ncDescribeResourceResponseType_reset_numberOfCoresAvailable(_ncDescribeResourceResponseType, env);
3664
_ncDescribeResourceResponseType->property_numberOfCoresAvailable = arg_numberOfCoresAvailable;
3665
_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable = AXIS2_TRUE;
3667
return AXIS2_SUCCESS;
3673
* resetter for numberOfCoresAvailable
3675
axis2_status_t AXIS2_CALL
3676
adb_ncDescribeResourceResponseType_reset_numberOfCoresAvailable(
3677
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3678
const axutil_env_t *env)
3682
void *element = NULL;
3684
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3685
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3688
_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable = AXIS2_FALSE;
3689
return AXIS2_SUCCESS;
3693
* Check whether numberOfCoresAvailable is nill
3695
axis2_bool_t AXIS2_CALL
3696
adb_ncDescribeResourceResponseType_is_numberOfCoresAvailable_nil(
3697
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3698
const axutil_env_t *env)
3700
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3701
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3703
return !_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable;
3707
* Set numberOfCoresAvailable to nill (currently the same as reset)
3709
axis2_status_t AXIS2_CALL
3710
adb_ncDescribeResourceResponseType_set_numberOfCoresAvailable_nil(
3711
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3712
const axutil_env_t *env)
3714
return adb_ncDescribeResourceResponseType_reset_numberOfCoresAvailable(_ncDescribeResourceResponseType, env);
3720
* getter for publicSubnets.
3722
axis2_char_t* AXIS2_CALL
3723
adb_ncDescribeResourceResponseType_get_publicSubnets(
3724
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3725
const axutil_env_t *env)
3728
AXIS2_ENV_CHECK(env, NULL);
3729
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
3732
return _ncDescribeResourceResponseType->property_publicSubnets;
3736
* setter for publicSubnets
3738
axis2_status_t AXIS2_CALL
3739
adb_ncDescribeResourceResponseType_set_publicSubnets(
3740
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3741
const axutil_env_t *env,
3742
const axis2_char_t* arg_publicSubnets)
3746
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3747
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3749
if(_ncDescribeResourceResponseType->is_valid_publicSubnets &&
3750
arg_publicSubnets == _ncDescribeResourceResponseType->property_publicSubnets)
3753
return AXIS2_SUCCESS;
3757
if(NULL == arg_publicSubnets)
3759
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "publicSubnets is being set to NULL, but it is not a nullable element");
3760
return AXIS2_FAILURE;
3762
adb_ncDescribeResourceResponseType_reset_publicSubnets(_ncDescribeResourceResponseType, env);
3765
if(NULL == arg_publicSubnets)
3767
/* We are already done */
3768
return AXIS2_SUCCESS;
3770
_ncDescribeResourceResponseType->property_publicSubnets = (axis2_char_t *)axutil_strdup(env, arg_publicSubnets);
3771
if(NULL == _ncDescribeResourceResponseType->property_publicSubnets)
3773
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for publicSubnets");
3774
return AXIS2_FAILURE;
3776
_ncDescribeResourceResponseType->is_valid_publicSubnets = AXIS2_TRUE;
3778
return AXIS2_SUCCESS;
3784
* resetter for publicSubnets
3786
axis2_status_t AXIS2_CALL
3787
adb_ncDescribeResourceResponseType_reset_publicSubnets(
3788
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3789
const axutil_env_t *env)
3793
void *element = NULL;
3795
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3796
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3802
if(_ncDescribeResourceResponseType->property_publicSubnets != NULL)
3806
AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_publicSubnets);
3807
_ncDescribeResourceResponseType->property_publicSubnets = NULL;
3812
_ncDescribeResourceResponseType->is_valid_publicSubnets = AXIS2_FALSE;
3813
return AXIS2_SUCCESS;
3817
* Check whether publicSubnets is nill
3819
axis2_bool_t AXIS2_CALL
3820
adb_ncDescribeResourceResponseType_is_publicSubnets_nil(
3821
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3822
const axutil_env_t *env)
3824
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3825
AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3827
return !_ncDescribeResourceResponseType->is_valid_publicSubnets;
3831
* Set publicSubnets to nill (currently the same as reset)
3833
axis2_status_t AXIS2_CALL
3834
adb_ncDescribeResourceResponseType_set_publicSubnets_nil(
3835
adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3836
const axutil_env_t *env)
3838
return adb_ncDescribeResourceResponseType_reset_publicSubnets(_ncDescribeResourceResponseType, env);
added
removed
cluster/generated/adb_ncDescribeResourceResponseType.c
