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_instanceType.h"
13
* This type was generated from the piece of schema that had
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_instanceType
23
axis2_char_t* property_reservationId;
26
axis2_bool_t is_valid_reservationId;
29
axis2_char_t* property_instanceId;
32
axis2_bool_t is_valid_instanceId;
35
axis2_char_t* property_imageId;
38
axis2_bool_t is_valid_imageId;
41
axis2_char_t* property_kernelId;
44
axis2_bool_t is_valid_kernelId;
47
axis2_char_t* property_ramdiskId;
50
axis2_bool_t is_valid_ramdiskId;
53
axis2_char_t* property_userId;
56
axis2_bool_t is_valid_userId;
59
axis2_char_t* property_keyName;
62
axis2_bool_t is_valid_keyName;
65
adb_virtualMachineType_t* property_instanceType;
68
axis2_bool_t is_valid_instanceType;
71
adb_netConfigType_t* property_netParams;
74
axis2_bool_t is_valid_netParams;
77
axis2_char_t* property_stateName;
80
axis2_bool_t is_valid_stateName;
83
axutil_date_time_t* property_launchTime;
86
axis2_bool_t is_valid_launchTime;
89
axis2_char_t* property_userData;
92
axis2_bool_t is_valid_userData;
95
axis2_char_t* property_launchIndex;
98
axis2_bool_t is_valid_launchIndex;
101
axutil_array_list_t* property_groupNames;
104
axis2_bool_t is_valid_groupNames;
107
axutil_array_list_t* property_volumes;
110
axis2_bool_t is_valid_volumes;
113
axis2_char_t* property_serviceTag;
116
axis2_bool_t is_valid_serviceTag;
123
/************************* Private Function prototypes ********************************/
126
axis2_status_t AXIS2_CALL
127
adb_instanceType_set_reservationId_nil(
128
adb_instanceType_t* _instanceType,
129
const axutil_env_t *env);
132
axis2_status_t AXIS2_CALL
133
adb_instanceType_set_instanceId_nil(
134
adb_instanceType_t* _instanceType,
135
const axutil_env_t *env);
138
axis2_status_t AXIS2_CALL
139
adb_instanceType_set_imageId_nil(
140
adb_instanceType_t* _instanceType,
141
const axutil_env_t *env);
144
axis2_status_t AXIS2_CALL
145
adb_instanceType_set_kernelId_nil(
146
adb_instanceType_t* _instanceType,
147
const axutil_env_t *env);
150
axis2_status_t AXIS2_CALL
151
adb_instanceType_set_ramdiskId_nil(
152
adb_instanceType_t* _instanceType,
153
const axutil_env_t *env);
156
axis2_status_t AXIS2_CALL
157
adb_instanceType_set_userId_nil(
158
adb_instanceType_t* _instanceType,
159
const axutil_env_t *env);
162
axis2_status_t AXIS2_CALL
163
adb_instanceType_set_keyName_nil(
164
adb_instanceType_t* _instanceType,
165
const axutil_env_t *env);
168
axis2_status_t AXIS2_CALL
169
adb_instanceType_set_instanceType_nil(
170
adb_instanceType_t* _instanceType,
171
const axutil_env_t *env);
174
axis2_status_t AXIS2_CALL
175
adb_instanceType_set_netParams_nil(
176
adb_instanceType_t* _instanceType,
177
const axutil_env_t *env);
180
axis2_status_t AXIS2_CALL
181
adb_instanceType_set_stateName_nil(
182
adb_instanceType_t* _instanceType,
183
const axutil_env_t *env);
186
axis2_status_t AXIS2_CALL
187
adb_instanceType_set_launchTime_nil(
188
adb_instanceType_t* _instanceType,
189
const axutil_env_t *env);
192
axis2_status_t AXIS2_CALL
193
adb_instanceType_set_userData_nil(
194
adb_instanceType_t* _instanceType,
195
const axutil_env_t *env);
198
axis2_status_t AXIS2_CALL
199
adb_instanceType_set_launchIndex_nil(
200
adb_instanceType_t* _instanceType,
201
const axutil_env_t *env);
203
axis2_status_t AXIS2_CALL
204
adb_instanceType_set_groupNames_nil_at(
205
adb_instanceType_t* _instanceType,
206
const axutil_env_t *env, int i);
209
axis2_status_t AXIS2_CALL
210
adb_instanceType_set_groupNames_nil(
211
adb_instanceType_t* _instanceType,
212
const axutil_env_t *env);
214
axis2_status_t AXIS2_CALL
215
adb_instanceType_set_volumes_nil_at(
216
adb_instanceType_t* _instanceType,
217
const axutil_env_t *env, int i);
220
axis2_status_t AXIS2_CALL
221
adb_instanceType_set_volumes_nil(
222
adb_instanceType_t* _instanceType,
223
const axutil_env_t *env);
226
axis2_status_t AXIS2_CALL
227
adb_instanceType_set_serviceTag_nil(
228
adb_instanceType_t* _instanceType,
229
const axutil_env_t *env);
233
/************************* Function Implmentations ********************************/
234
adb_instanceType_t* AXIS2_CALL
235
adb_instanceType_create(
236
const axutil_env_t *env)
238
adb_instanceType_t *_instanceType = NULL;
240
AXIS2_ENV_CHECK(env, NULL);
242
_instanceType = (adb_instanceType_t *) AXIS2_MALLOC(env->
243
allocator, sizeof(adb_instanceType_t));
245
if(NULL == _instanceType)
247
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
251
memset(_instanceType, 0, sizeof(adb_instanceType_t));
253
_instanceType->property_reservationId = NULL;
254
_instanceType->is_valid_reservationId = AXIS2_FALSE;
255
_instanceType->property_instanceId = NULL;
256
_instanceType->is_valid_instanceId = AXIS2_FALSE;
257
_instanceType->property_imageId = NULL;
258
_instanceType->is_valid_imageId = AXIS2_FALSE;
259
_instanceType->property_kernelId = NULL;
260
_instanceType->is_valid_kernelId = AXIS2_FALSE;
261
_instanceType->property_ramdiskId = NULL;
262
_instanceType->is_valid_ramdiskId = AXIS2_FALSE;
263
_instanceType->property_userId = NULL;
264
_instanceType->is_valid_userId = AXIS2_FALSE;
265
_instanceType->property_keyName = NULL;
266
_instanceType->is_valid_keyName = AXIS2_FALSE;
267
_instanceType->property_instanceType = NULL;
268
_instanceType->is_valid_instanceType = AXIS2_FALSE;
269
_instanceType->property_netParams = NULL;
270
_instanceType->is_valid_netParams = AXIS2_FALSE;
271
_instanceType->property_stateName = NULL;
272
_instanceType->is_valid_stateName = AXIS2_FALSE;
273
_instanceType->property_launchTime = NULL;
274
_instanceType->is_valid_launchTime = AXIS2_FALSE;
275
_instanceType->property_userData = NULL;
276
_instanceType->is_valid_userData = AXIS2_FALSE;
277
_instanceType->property_launchIndex = NULL;
278
_instanceType->is_valid_launchIndex = AXIS2_FALSE;
279
_instanceType->property_groupNames = NULL;
280
_instanceType->is_valid_groupNames = AXIS2_FALSE;
281
_instanceType->property_volumes = NULL;
282
_instanceType->is_valid_volumes = AXIS2_FALSE;
283
_instanceType->property_serviceTag = NULL;
284
_instanceType->is_valid_serviceTag = AXIS2_FALSE;
287
return _instanceType;
290
axis2_status_t AXIS2_CALL
291
adb_instanceType_free (
292
adb_instanceType_t* _instanceType,
293
const axutil_env_t *env)
298
void *element = NULL;
301
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
302
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
304
adb_instanceType_reset_reservationId(_instanceType, env);
305
adb_instanceType_reset_instanceId(_instanceType, env);
306
adb_instanceType_reset_imageId(_instanceType, env);
307
adb_instanceType_reset_kernelId(_instanceType, env);
308
adb_instanceType_reset_ramdiskId(_instanceType, env);
309
adb_instanceType_reset_userId(_instanceType, env);
310
adb_instanceType_reset_keyName(_instanceType, env);
311
adb_instanceType_reset_instanceType(_instanceType, env);
312
adb_instanceType_reset_netParams(_instanceType, env);
313
adb_instanceType_reset_stateName(_instanceType, env);
314
adb_instanceType_reset_launchTime(_instanceType, env);
315
adb_instanceType_reset_userData(_instanceType, env);
316
adb_instanceType_reset_launchIndex(_instanceType, env);
317
adb_instanceType_reset_groupNames(_instanceType, env);
318
adb_instanceType_reset_volumes(_instanceType, env);
319
adb_instanceType_reset_serviceTag(_instanceType, env);
324
AXIS2_FREE(env->allocator, _instanceType);
325
_instanceType = NULL;
327
return AXIS2_SUCCESS;
333
axis2_status_t AXIS2_CALL
334
adb_instanceType_deserialize(
335
adb_instanceType_t* _instanceType,
336
const axutil_env_t *env,
337
axiom_node_t **dp_parent,
338
axis2_bool_t *dp_is_early_node_valid,
339
axis2_bool_t dont_care_minoccurs)
341
axiom_node_t *parent = *dp_parent;
343
axis2_status_t status = AXIS2_SUCCESS;
345
void *element = NULL;
347
axis2_char_t* text_value = NULL;
348
axutil_qname_t *qname = NULL;
351
axutil_array_list_t *arr_list = NULL;
353
int sequence_broken = 0;
354
axiom_node_t *tmp_node = NULL;
356
axutil_qname_t *element_qname = NULL;
358
axiom_node_t *first_node = NULL;
359
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
360
axiom_node_t *current_node = NULL;
361
axiom_element_t *current_element = NULL;
363
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
364
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
368
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
370
parent = axiom_node_get_next_sibling(parent, env);
374
/* This should be checked before everything */
375
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
376
"Failed in building adb object for instanceType : "
377
"NULL elemenet can not be passed to deserialize");
378
return AXIS2_FAILURE;
382
first_node = axiom_node_get_first_child(parent, env);
388
* building reservationId element
393
current_node = first_node;
394
is_early_node_valid = AXIS2_FALSE;
397
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
399
current_node = axiom_node_get_next_sibling(current_node, env);
401
if(current_node != NULL)
403
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
404
qname = axiom_element_get_qname(current_element, env, current_node);
407
element_qname = axutil_qname_create(env, "reservationId", "http://eucalyptus.ucsb.edu/", NULL);
411
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
413
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
415
is_early_node_valid = AXIS2_TRUE;
419
text_value = axiom_element_get_text(current_element, env, current_node);
420
if(text_value != NULL)
422
status = adb_instanceType_set_reservationId(_instanceType, env,
429
* axis2_qname_t *qname = NULL;
430
* axiom_attribute_t *the_attri = NULL;
432
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
433
* the_attri = axiom_element_get_attribute(current_element, env, qname);
435
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
437
axiom_attribute_t *the_attri = NULL;
438
axis2_char_t *attrib_text = NULL;
439
axutil_hash_t *attribute_hash = NULL;
441
attribute_hash = axiom_element_get_all_attributes(current_element, env);
446
axutil_hash_index_t *hi;
450
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
452
axutil_hash_this(hi, &key, NULL, &val);
454
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
456
the_attri = (axiom_attribute_t*)val;
464
attrib_text = axiom_attribute_get_value(the_attri, env);
468
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
469
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
472
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
474
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element reservationId");
475
status = AXIS2_FAILURE;
479
/* after all, we found this is a empty string */
480
status = adb_instanceType_set_reservationId(_instanceType, env,
485
if(AXIS2_FAILURE == status)
487
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for reservationId ");
490
axutil_qname_free(element_qname, env);
492
return AXIS2_FAILURE;
496
else if(!dont_care_minoccurs)
500
axutil_qname_free(element_qname, env);
502
/* this is not a nillable element*/
503
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element reservationId missing");
504
return AXIS2_FAILURE;
509
axutil_qname_free(element_qname, env);
510
element_qname = NULL;
516
* building instanceId element
522
* because elements are ordered this works fine
526
if(current_node != NULL && is_early_node_valid)
528
current_node = axiom_node_get_next_sibling(current_node, env);
531
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
533
current_node = axiom_node_get_next_sibling(current_node, env);
535
if(current_node != NULL)
537
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
538
qname = axiom_element_get_qname(current_element, env, current_node);
542
is_early_node_valid = AXIS2_FALSE;
544
element_qname = axutil_qname_create(env, "instanceId", "http://eucalyptus.ucsb.edu/", NULL);
548
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
550
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
552
is_early_node_valid = AXIS2_TRUE;
556
text_value = axiom_element_get_text(current_element, env, current_node);
557
if(text_value != NULL)
559
status = adb_instanceType_set_instanceId(_instanceType, env,
566
* axis2_qname_t *qname = NULL;
567
* axiom_attribute_t *the_attri = NULL;
569
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
570
* the_attri = axiom_element_get_attribute(current_element, env, qname);
572
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
574
axiom_attribute_t *the_attri = NULL;
575
axis2_char_t *attrib_text = NULL;
576
axutil_hash_t *attribute_hash = NULL;
578
attribute_hash = axiom_element_get_all_attributes(current_element, env);
583
axutil_hash_index_t *hi;
587
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
589
axutil_hash_this(hi, &key, NULL, &val);
591
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
593
the_attri = (axiom_attribute_t*)val;
601
attrib_text = axiom_attribute_get_value(the_attri, env);
605
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
606
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
609
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
611
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceId");
612
status = AXIS2_FAILURE;
616
/* after all, we found this is a empty string */
617
status = adb_instanceType_set_instanceId(_instanceType, env,
622
if(AXIS2_FAILURE == status)
624
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceId ");
627
axutil_qname_free(element_qname, env);
629
return AXIS2_FAILURE;
633
else if(!dont_care_minoccurs)
637
axutil_qname_free(element_qname, env);
639
/* this is not a nillable element*/
640
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element instanceId missing");
641
return AXIS2_FAILURE;
646
axutil_qname_free(element_qname, env);
647
element_qname = NULL;
653
* building imageId element
659
* because elements are ordered this works fine
663
if(current_node != NULL && is_early_node_valid)
665
current_node = axiom_node_get_next_sibling(current_node, env);
668
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
670
current_node = axiom_node_get_next_sibling(current_node, env);
672
if(current_node != NULL)
674
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
675
qname = axiom_element_get_qname(current_element, env, current_node);
679
is_early_node_valid = AXIS2_FALSE;
681
element_qname = axutil_qname_create(env, "imageId", "http://eucalyptus.ucsb.edu/", NULL);
685
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
687
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
689
is_early_node_valid = AXIS2_TRUE;
693
text_value = axiom_element_get_text(current_element, env, current_node);
694
if(text_value != NULL)
696
status = adb_instanceType_set_imageId(_instanceType, env,
703
* axis2_qname_t *qname = NULL;
704
* axiom_attribute_t *the_attri = NULL;
706
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
707
* the_attri = axiom_element_get_attribute(current_element, env, qname);
709
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
711
axiom_attribute_t *the_attri = NULL;
712
axis2_char_t *attrib_text = NULL;
713
axutil_hash_t *attribute_hash = NULL;
715
attribute_hash = axiom_element_get_all_attributes(current_element, env);
720
axutil_hash_index_t *hi;
724
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
726
axutil_hash_this(hi, &key, NULL, &val);
728
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
730
the_attri = (axiom_attribute_t*)val;
738
attrib_text = axiom_attribute_get_value(the_attri, env);
742
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
743
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
746
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
748
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element imageId");
749
status = AXIS2_FAILURE;
753
/* after all, we found this is a empty string */
754
status = adb_instanceType_set_imageId(_instanceType, env,
759
if(AXIS2_FAILURE == status)
761
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for imageId ");
764
axutil_qname_free(element_qname, env);
766
return AXIS2_FAILURE;
770
else if(!dont_care_minoccurs)
774
axutil_qname_free(element_qname, env);
776
/* this is not a nillable element*/
777
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element imageId missing");
778
return AXIS2_FAILURE;
783
axutil_qname_free(element_qname, env);
784
element_qname = NULL;
790
* building kernelId element
796
* because elements are ordered this works fine
800
if(current_node != NULL && is_early_node_valid)
802
current_node = axiom_node_get_next_sibling(current_node, env);
805
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
807
current_node = axiom_node_get_next_sibling(current_node, env);
809
if(current_node != NULL)
811
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
812
qname = axiom_element_get_qname(current_element, env, current_node);
816
is_early_node_valid = AXIS2_FALSE;
818
element_qname = axutil_qname_create(env, "kernelId", "http://eucalyptus.ucsb.edu/", NULL);
822
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
824
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
826
is_early_node_valid = AXIS2_TRUE;
830
text_value = axiom_element_get_text(current_element, env, current_node);
831
if(text_value != NULL)
833
status = adb_instanceType_set_kernelId(_instanceType, env,
840
* axis2_qname_t *qname = NULL;
841
* axiom_attribute_t *the_attri = NULL;
843
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
844
* the_attri = axiom_element_get_attribute(current_element, env, qname);
846
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
848
axiom_attribute_t *the_attri = NULL;
849
axis2_char_t *attrib_text = NULL;
850
axutil_hash_t *attribute_hash = NULL;
852
attribute_hash = axiom_element_get_all_attributes(current_element, env);
857
axutil_hash_index_t *hi;
861
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
863
axutil_hash_this(hi, &key, NULL, &val);
865
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
867
the_attri = (axiom_attribute_t*)val;
875
attrib_text = axiom_attribute_get_value(the_attri, env);
879
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
880
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
883
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
885
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element kernelId");
886
status = AXIS2_FAILURE;
890
/* after all, we found this is a empty string */
891
status = adb_instanceType_set_kernelId(_instanceType, env,
896
if(AXIS2_FAILURE == status)
898
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for kernelId ");
901
axutil_qname_free(element_qname, env);
903
return AXIS2_FAILURE;
907
else if(!dont_care_minoccurs)
911
axutil_qname_free(element_qname, env);
913
/* this is not a nillable element*/
914
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element kernelId missing");
915
return AXIS2_FAILURE;
920
axutil_qname_free(element_qname, env);
921
element_qname = NULL;
927
* building ramdiskId element
933
* because elements are ordered this works fine
937
if(current_node != NULL && is_early_node_valid)
939
current_node = axiom_node_get_next_sibling(current_node, env);
942
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
944
current_node = axiom_node_get_next_sibling(current_node, env);
946
if(current_node != NULL)
948
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
949
qname = axiom_element_get_qname(current_element, env, current_node);
953
is_early_node_valid = AXIS2_FALSE;
955
element_qname = axutil_qname_create(env, "ramdiskId", "http://eucalyptus.ucsb.edu/", NULL);
959
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
961
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
963
is_early_node_valid = AXIS2_TRUE;
967
text_value = axiom_element_get_text(current_element, env, current_node);
968
if(text_value != NULL)
970
status = adb_instanceType_set_ramdiskId(_instanceType, env,
977
* axis2_qname_t *qname = NULL;
978
* axiom_attribute_t *the_attri = NULL;
980
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
981
* the_attri = axiom_element_get_attribute(current_element, env, qname);
983
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
985
axiom_attribute_t *the_attri = NULL;
986
axis2_char_t *attrib_text = NULL;
987
axutil_hash_t *attribute_hash = NULL;
989
attribute_hash = axiom_element_get_all_attributes(current_element, env);
994
axutil_hash_index_t *hi;
998
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1000
axutil_hash_this(hi, &key, NULL, &val);
1002
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1004
the_attri = (axiom_attribute_t*)val;
1012
attrib_text = axiom_attribute_get_value(the_attri, env);
1016
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1017
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1020
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1022
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element ramdiskId");
1023
status = AXIS2_FAILURE;
1027
/* after all, we found this is a empty string */
1028
status = adb_instanceType_set_ramdiskId(_instanceType, env,
1033
if(AXIS2_FAILURE == status)
1035
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for ramdiskId ");
1038
axutil_qname_free(element_qname, env);
1040
return AXIS2_FAILURE;
1046
axutil_qname_free(element_qname, env);
1047
element_qname = NULL;
1053
* building userId element
1059
* because elements are ordered this works fine
1063
if(current_node != NULL && is_early_node_valid)
1065
current_node = axiom_node_get_next_sibling(current_node, env);
1068
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1070
current_node = axiom_node_get_next_sibling(current_node, env);
1072
if(current_node != NULL)
1074
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1075
qname = axiom_element_get_qname(current_element, env, current_node);
1079
is_early_node_valid = AXIS2_FALSE;
1081
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
1085
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1087
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1089
is_early_node_valid = AXIS2_TRUE;
1093
text_value = axiom_element_get_text(current_element, env, current_node);
1094
if(text_value != NULL)
1096
status = adb_instanceType_set_userId(_instanceType, env,
1103
* axis2_qname_t *qname = NULL;
1104
* axiom_attribute_t *the_attri = NULL;
1106
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1107
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1109
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1111
axiom_attribute_t *the_attri = NULL;
1112
axis2_char_t *attrib_text = NULL;
1113
axutil_hash_t *attribute_hash = NULL;
1115
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1120
axutil_hash_index_t *hi;
1124
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1126
axutil_hash_this(hi, &key, NULL, &val);
1128
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1130
the_attri = (axiom_attribute_t*)val;
1138
attrib_text = axiom_attribute_get_value(the_attri, env);
1142
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1143
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1146
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1148
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
1149
status = AXIS2_FAILURE;
1153
/* after all, we found this is a empty string */
1154
status = adb_instanceType_set_userId(_instanceType, env,
1159
if(AXIS2_FAILURE == status)
1161
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
1164
axutil_qname_free(element_qname, env);
1166
return AXIS2_FAILURE;
1170
else if(!dont_care_minoccurs)
1174
axutil_qname_free(element_qname, env);
1176
/* this is not a nillable element*/
1177
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element userId missing");
1178
return AXIS2_FAILURE;
1183
axutil_qname_free(element_qname, env);
1184
element_qname = NULL;
1190
* building keyName element
1196
* because elements are ordered this works fine
1200
if(current_node != NULL && is_early_node_valid)
1202
current_node = axiom_node_get_next_sibling(current_node, env);
1205
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1207
current_node = axiom_node_get_next_sibling(current_node, env);
1209
if(current_node != NULL)
1211
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1212
qname = axiom_element_get_qname(current_element, env, current_node);
1216
is_early_node_valid = AXIS2_FALSE;
1218
element_qname = axutil_qname_create(env, "keyName", "http://eucalyptus.ucsb.edu/", NULL);
1222
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1224
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1226
is_early_node_valid = AXIS2_TRUE;
1230
text_value = axiom_element_get_text(current_element, env, current_node);
1231
if(text_value != NULL)
1233
status = adb_instanceType_set_keyName(_instanceType, env,
1240
* axis2_qname_t *qname = NULL;
1241
* axiom_attribute_t *the_attri = NULL;
1243
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1244
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1246
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1248
axiom_attribute_t *the_attri = NULL;
1249
axis2_char_t *attrib_text = NULL;
1250
axutil_hash_t *attribute_hash = NULL;
1252
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1257
axutil_hash_index_t *hi;
1261
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1263
axutil_hash_this(hi, &key, NULL, &val);
1265
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1267
the_attri = (axiom_attribute_t*)val;
1275
attrib_text = axiom_attribute_get_value(the_attri, env);
1279
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1280
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1283
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1285
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element keyName");
1286
status = AXIS2_FAILURE;
1290
/* after all, we found this is a empty string */
1291
status = adb_instanceType_set_keyName(_instanceType, env,
1296
if(AXIS2_FAILURE == status)
1298
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for keyName ");
1301
axutil_qname_free(element_qname, env);
1303
return AXIS2_FAILURE;
1307
else if(!dont_care_minoccurs)
1311
axutil_qname_free(element_qname, env);
1313
/* this is not a nillable element*/
1314
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element keyName missing");
1315
return AXIS2_FAILURE;
1320
axutil_qname_free(element_qname, env);
1321
element_qname = NULL;
1327
* building instanceType element
1333
* because elements are ordered this works fine
1337
if(current_node != NULL && is_early_node_valid)
1339
current_node = axiom_node_get_next_sibling(current_node, env);
1342
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1344
current_node = axiom_node_get_next_sibling(current_node, env);
1346
if(current_node != NULL)
1348
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1349
qname = axiom_element_get_qname(current_element, env, current_node);
1353
is_early_node_valid = AXIS2_FALSE;
1355
element_qname = axutil_qname_create(env, "instanceType", "http://eucalyptus.ucsb.edu/", NULL);
1358
if (adb_virtualMachineType_is_particle() ||
1359
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1361
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1363
is_early_node_valid = AXIS2_TRUE;
1367
element = (void*)adb_virtualMachineType_create(env);
1369
status = adb_virtualMachineType_deserialize((adb_virtualMachineType_t*)element,
1370
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
1371
if(AXIS2_FAILURE == status)
1373
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element instanceType");
1377
status = adb_instanceType_set_instanceType(_instanceType, env,
1378
(adb_virtualMachineType_t*)element);
1381
if(AXIS2_FAILURE == status)
1383
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceType ");
1386
axutil_qname_free(element_qname, env);
1388
return AXIS2_FAILURE;
1392
else if(!dont_care_minoccurs)
1396
axutil_qname_free(element_qname, env);
1398
/* this is not a nillable element*/
1399
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element instanceType missing");
1400
return AXIS2_FAILURE;
1405
axutil_qname_free(element_qname, env);
1406
element_qname = NULL;
1412
* building netParams element
1418
* because elements are ordered this works fine
1422
if(current_node != NULL && is_early_node_valid)
1424
current_node = axiom_node_get_next_sibling(current_node, env);
1427
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1429
current_node = axiom_node_get_next_sibling(current_node, env);
1431
if(current_node != NULL)
1433
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1434
qname = axiom_element_get_qname(current_element, env, current_node);
1438
is_early_node_valid = AXIS2_FALSE;
1440
element_qname = axutil_qname_create(env, "netParams", "http://eucalyptus.ucsb.edu/", NULL);
1443
if (adb_netConfigType_is_particle() ||
1444
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1446
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1448
is_early_node_valid = AXIS2_TRUE;
1452
element = (void*)adb_netConfigType_create(env);
1454
status = adb_netConfigType_deserialize((adb_netConfigType_t*)element,
1455
env, ¤t_node, &is_early_node_valid, AXIS2_FALSE);
1456
if(AXIS2_FAILURE == status)
1458
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element netParams");
1462
status = adb_instanceType_set_netParams(_instanceType, env,
1463
(adb_netConfigType_t*)element);
1466
if(AXIS2_FAILURE == status)
1468
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for netParams ");
1471
axutil_qname_free(element_qname, env);
1473
return AXIS2_FAILURE;
1479
axutil_qname_free(element_qname, env);
1480
element_qname = NULL;
1486
* building stateName element
1492
* because elements are ordered this works fine
1496
if(current_node != NULL && is_early_node_valid)
1498
current_node = axiom_node_get_next_sibling(current_node, env);
1501
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1503
current_node = axiom_node_get_next_sibling(current_node, env);
1505
if(current_node != NULL)
1507
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1508
qname = axiom_element_get_qname(current_element, env, current_node);
1512
is_early_node_valid = AXIS2_FALSE;
1514
element_qname = axutil_qname_create(env, "stateName", "http://eucalyptus.ucsb.edu/", NULL);
1518
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1520
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1522
is_early_node_valid = AXIS2_TRUE;
1526
text_value = axiom_element_get_text(current_element, env, current_node);
1527
if(text_value != NULL)
1529
status = adb_instanceType_set_stateName(_instanceType, env,
1536
* axis2_qname_t *qname = NULL;
1537
* axiom_attribute_t *the_attri = NULL;
1539
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1540
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1542
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1544
axiom_attribute_t *the_attri = NULL;
1545
axis2_char_t *attrib_text = NULL;
1546
axutil_hash_t *attribute_hash = NULL;
1548
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1553
axutil_hash_index_t *hi;
1557
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1559
axutil_hash_this(hi, &key, NULL, &val);
1561
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1563
the_attri = (axiom_attribute_t*)val;
1571
attrib_text = axiom_attribute_get_value(the_attri, env);
1575
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1576
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1579
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1581
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element stateName");
1582
status = AXIS2_FAILURE;
1586
/* after all, we found this is a empty string */
1587
status = adb_instanceType_set_stateName(_instanceType, env,
1592
if(AXIS2_FAILURE == status)
1594
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for stateName ");
1597
axutil_qname_free(element_qname, env);
1599
return AXIS2_FAILURE;
1603
else if(!dont_care_minoccurs)
1607
axutil_qname_free(element_qname, env);
1609
/* this is not a nillable element*/
1610
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element stateName missing");
1611
return AXIS2_FAILURE;
1616
axutil_qname_free(element_qname, env);
1617
element_qname = NULL;
1623
* building launchTime element
1629
* because elements are ordered this works fine
1633
if(current_node != NULL && is_early_node_valid)
1635
current_node = axiom_node_get_next_sibling(current_node, env);
1638
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1640
current_node = axiom_node_get_next_sibling(current_node, env);
1642
if(current_node != NULL)
1644
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1645
qname = axiom_element_get_qname(current_element, env, current_node);
1649
is_early_node_valid = AXIS2_FALSE;
1651
element_qname = axutil_qname_create(env, "launchTime", "http://eucalyptus.ucsb.edu/", NULL);
1655
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1657
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1659
is_early_node_valid = AXIS2_TRUE;
1663
text_value = axiom_element_get_text(current_element, env, current_node);
1664
if(text_value != NULL)
1666
element = (void*)axutil_date_time_create(env);
1667
status = axutil_date_time_deserialize_date_time((axutil_date_time_t*)element, env,
1669
if(AXIS2_FAILURE == status)
1673
axutil_date_time_free((axutil_date_time_t*)element, env);
1675
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element launchTime ");
1679
status = adb_instanceType_set_launchTime(_instanceType, env,
1680
(axutil_date_time_t*)element);
1686
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element launchTime");
1687
status = AXIS2_FAILURE;
1690
if(AXIS2_FAILURE == status)
1692
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for launchTime ");
1695
axutil_qname_free(element_qname, env);
1697
return AXIS2_FAILURE;
1703
axutil_qname_free(element_qname, env);
1704
element_qname = NULL;
1710
* building userData element
1716
* because elements are ordered this works fine
1720
if(current_node != NULL && is_early_node_valid)
1722
current_node = axiom_node_get_next_sibling(current_node, env);
1725
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1727
current_node = axiom_node_get_next_sibling(current_node, env);
1729
if(current_node != NULL)
1731
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1732
qname = axiom_element_get_qname(current_element, env, current_node);
1736
is_early_node_valid = AXIS2_FALSE;
1738
element_qname = axutil_qname_create(env, "userData", "http://eucalyptus.ucsb.edu/", NULL);
1742
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1744
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1746
is_early_node_valid = AXIS2_TRUE;
1750
text_value = axiom_element_get_text(current_element, env, current_node);
1751
if(text_value != NULL)
1753
status = adb_instanceType_set_userData(_instanceType, env,
1760
* axis2_qname_t *qname = NULL;
1761
* axiom_attribute_t *the_attri = NULL;
1763
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1764
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1766
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1768
axiom_attribute_t *the_attri = NULL;
1769
axis2_char_t *attrib_text = NULL;
1770
axutil_hash_t *attribute_hash = NULL;
1772
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1777
axutil_hash_index_t *hi;
1781
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1783
axutil_hash_this(hi, &key, NULL, &val);
1785
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1787
the_attri = (axiom_attribute_t*)val;
1795
attrib_text = axiom_attribute_get_value(the_attri, env);
1799
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1800
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1803
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1805
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userData");
1806
status = AXIS2_FAILURE;
1810
/* after all, we found this is a empty string */
1811
status = adb_instanceType_set_userData(_instanceType, env,
1816
if(AXIS2_FAILURE == status)
1818
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userData ");
1821
axutil_qname_free(element_qname, env);
1823
return AXIS2_FAILURE;
1829
axutil_qname_free(element_qname, env);
1830
element_qname = NULL;
1836
* building launchIndex element
1842
* because elements are ordered this works fine
1846
if(current_node != NULL && is_early_node_valid)
1848
current_node = axiom_node_get_next_sibling(current_node, env);
1851
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1853
current_node = axiom_node_get_next_sibling(current_node, env);
1855
if(current_node != NULL)
1857
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1858
qname = axiom_element_get_qname(current_element, env, current_node);
1862
is_early_node_valid = AXIS2_FALSE;
1864
element_qname = axutil_qname_create(env, "launchIndex", "http://eucalyptus.ucsb.edu/", NULL);
1868
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1870
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1872
is_early_node_valid = AXIS2_TRUE;
1876
text_value = axiom_element_get_text(current_element, env, current_node);
1877
if(text_value != NULL)
1879
status = adb_instanceType_set_launchIndex(_instanceType, env,
1886
* axis2_qname_t *qname = NULL;
1887
* axiom_attribute_t *the_attri = NULL;
1889
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1890
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1892
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1894
axiom_attribute_t *the_attri = NULL;
1895
axis2_char_t *attrib_text = NULL;
1896
axutil_hash_t *attribute_hash = NULL;
1898
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1903
axutil_hash_index_t *hi;
1907
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1909
axutil_hash_this(hi, &key, NULL, &val);
1911
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1913
the_attri = (axiom_attribute_t*)val;
1921
attrib_text = axiom_attribute_get_value(the_attri, env);
1925
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1926
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1929
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1931
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element launchIndex");
1932
status = AXIS2_FAILURE;
1936
/* after all, we found this is a empty string */
1937
status = adb_instanceType_set_launchIndex(_instanceType, env,
1942
if(AXIS2_FAILURE == status)
1944
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for launchIndex ");
1947
axutil_qname_free(element_qname, env);
1949
return AXIS2_FAILURE;
1955
axutil_qname_free(element_qname, env);
1956
element_qname = NULL;
1960
* building groupNames array
1962
arr_list = axutil_array_list_create(env, 10);
1967
* building groupNames element
1972
element_qname = axutil_qname_create(env, "groupNames", "http://eucalyptus.ucsb.edu/", NULL);
1975
for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
1978
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1980
current_node =axiom_node_get_next_sibling(current_node, env);
1981
is_early_node_valid = AXIS2_FALSE;
1985
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1986
qname = axiom_element_get_qname(current_element, env, current_node);
1988
if (axutil_qname_equals(element_qname, env, qname))
1991
is_early_node_valid = AXIS2_TRUE;
1994
text_value = axiom_element_get_text(current_element, env, current_node);
1995
if(text_value != NULL)
1997
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
2003
* axis2_qname_t *qname = NULL;
2004
* axiom_attribute_t *the_attri = NULL;
2006
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
2007
* the_attri = axiom_element_get_attribute(current_element, env, qname);
2010
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
2012
axiom_attribute_t *the_attri = NULL;
2013
axis2_char_t *attrib_text = NULL;
2014
axutil_hash_t *attribute_hash = NULL;
2016
attribute_hash = axiom_element_get_all_attributes(current_element, env);
2021
axutil_hash_index_t *hi;
2025
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
2027
axutil_hash_this(hi, &key, NULL, &val);
2029
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
2031
the_attri = (axiom_attribute_t*)val;
2039
attrib_text = axiom_attribute_get_value(the_attri, env);
2043
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
2044
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
2047
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
2049
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element groupNames");
2050
status = AXIS2_FAILURE;
2054
/* after all, we found this is a empty string */
2055
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
2059
if(AXIS2_FAILURE == status)
2061
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for groupNames ");
2064
axutil_qname_free(element_qname, env);
2068
axutil_array_list_free(arr_list, env);
2070
return AXIS2_FAILURE;
2074
current_node = axiom_node_get_next_sibling(current_node, env);
2078
is_early_node_valid = AXIS2_FALSE;
2079
sequence_broken = 1;
2087
/* found element out of order */
2088
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "groupNames (@minOccurs = '0') only have %d elements", i);
2091
axutil_qname_free(element_qname, env);
2095
axutil_array_list_free(arr_list, env);
2097
return AXIS2_FAILURE;
2101
if(0 == axutil_array_list_size(arr_list,env))
2103
axutil_array_list_free(arr_list, env);
2107
status = adb_instanceType_set_groupNames(_instanceType, env,
2114
axutil_qname_free(element_qname, env);
2115
element_qname = NULL;
2119
* building volumes array
2121
arr_list = axutil_array_list_create(env, 10);
2126
* building volumes element
2131
element_qname = axutil_qname_create(env, "volumes", "http://eucalyptus.ucsb.edu/", NULL);
2134
for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
2137
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
2139
current_node =axiom_node_get_next_sibling(current_node, env);
2140
is_early_node_valid = AXIS2_FALSE;
2144
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
2145
qname = axiom_element_get_qname(current_element, env, current_node);
2147
if (axutil_qname_equals(element_qname, env, qname))
2150
is_early_node_valid = AXIS2_TRUE;
2153
element = (void*)adb_volumeType_create(env);
2155
status = adb_volumeType_deserialize((adb_volumeType_t*)element, env,
2156
¤t_node, &is_early_node_valid, AXIS2_FALSE);
2158
if(AXIS2_FAILURE == status)
2160
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element volumes ");
2164
axutil_array_list_add_at(arr_list, env, i, element);
2167
if(AXIS2_FAILURE == status)
2169
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for volumes ");
2172
axutil_qname_free(element_qname, env);
2176
axutil_array_list_free(arr_list, env);
2178
return AXIS2_FAILURE;
2182
current_node = axiom_node_get_next_sibling(current_node, env);
2186
is_early_node_valid = AXIS2_FALSE;
2187
sequence_broken = 1;
2195
/* found element out of order */
2196
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "volumes (@minOccurs = '0') only have %d elements", i);
2199
axutil_qname_free(element_qname, env);
2203
axutil_array_list_free(arr_list, env);
2205
return AXIS2_FAILURE;
2209
if(0 == axutil_array_list_size(arr_list,env))
2211
axutil_array_list_free(arr_list, env);
2215
status = adb_instanceType_set_volumes(_instanceType, env,
2222
axutil_qname_free(element_qname, env);
2223
element_qname = NULL;
2229
* building serviceTag element
2235
* because elements are ordered this works fine
2239
if(current_node != NULL && is_early_node_valid)
2241
current_node = axiom_node_get_next_sibling(current_node, env);
2244
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
2246
current_node = axiom_node_get_next_sibling(current_node, env);
2248
if(current_node != NULL)
2250
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
2251
qname = axiom_element_get_qname(current_element, env, current_node);
2255
is_early_node_valid = AXIS2_FALSE;
2257
element_qname = axutil_qname_create(env, "serviceTag", "http://eucalyptus.ucsb.edu/", NULL);
2261
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
2263
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
2265
is_early_node_valid = AXIS2_TRUE;
2269
text_value = axiom_element_get_text(current_element, env, current_node);
2270
if(text_value != NULL)
2272
status = adb_instanceType_set_serviceTag(_instanceType, env,
2279
* axis2_qname_t *qname = NULL;
2280
* axiom_attribute_t *the_attri = NULL;
2282
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
2283
* the_attri = axiom_element_get_attribute(current_element, env, qname);
2285
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
2287
axiom_attribute_t *the_attri = NULL;
2288
axis2_char_t *attrib_text = NULL;
2289
axutil_hash_t *attribute_hash = NULL;
2291
attribute_hash = axiom_element_get_all_attributes(current_element, env);
2296
axutil_hash_index_t *hi;
2300
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
2302
axutil_hash_this(hi, &key, NULL, &val);
2304
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
2306
the_attri = (axiom_attribute_t*)val;
2314
attrib_text = axiom_attribute_get_value(the_attri, env);
2318
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
2319
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
2322
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
2324
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element serviceTag");
2325
status = AXIS2_FAILURE;
2329
/* after all, we found this is a empty string */
2330
status = adb_instanceType_set_serviceTag(_instanceType, env,
2335
if(AXIS2_FAILURE == status)
2337
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for serviceTag ");
2340
axutil_qname_free(element_qname, env);
2342
return AXIS2_FAILURE;
2348
axutil_qname_free(element_qname, env);
2349
element_qname = NULL;
2355
axis2_bool_t AXIS2_CALL
2356
adb_instanceType_is_particle()
2365
adb_instanceType_declare_parent_namespaces(
2366
adb_instanceType_t* _instanceType,
2367
const axutil_env_t *env, axiom_element_t *parent_element,
2368
axutil_hash_t *namespaces, int *next_ns_index)
2371
/* Here this is an empty function, Nothing to declare */
2377
axiom_node_t* AXIS2_CALL
2378
adb_instanceType_serialize(
2379
adb_instanceType_t* _instanceType,
2380
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)
2384
axis2_char_t *string_to_stream;
2387
axiom_node_t *current_node = NULL;
2392
axiom_namespace_t *ns1 = NULL;
2394
axis2_char_t *qname_uri = NULL;
2395
axis2_char_t *qname_prefix = NULL;
2396
axis2_char_t *p_prefix = NULL;
2397
axis2_bool_t ns_already_defined;
2401
void *element = NULL;
2403
axis2_char_t *text_value_1;
2404
axis2_char_t *text_value_1_temp;
2406
axis2_char_t *text_value_2;
2407
axis2_char_t *text_value_2_temp;
2409
axis2_char_t *text_value_3;
2410
axis2_char_t *text_value_3_temp;
2412
axis2_char_t *text_value_4;
2413
axis2_char_t *text_value_4_temp;
2415
axis2_char_t *text_value_5;
2416
axis2_char_t *text_value_5_temp;
2418
axis2_char_t *text_value_6;
2419
axis2_char_t *text_value_6_temp;
2421
axis2_char_t *text_value_7;
2422
axis2_char_t *text_value_7_temp;
2424
axis2_char_t text_value_8[64];
2426
axis2_char_t text_value_9[64];
2428
axis2_char_t *text_value_10;
2429
axis2_char_t *text_value_10_temp;
2431
axis2_char_t *text_value_11;
2432
axis2_char_t *text_value_11_temp;
2434
axis2_char_t *text_value_12;
2435
axis2_char_t *text_value_12_temp;
2437
axis2_char_t *text_value_13;
2438
axis2_char_t *text_value_13_temp;
2440
axis2_char_t *text_value_14;
2441
axis2_char_t *text_value_14_temp;
2443
axis2_char_t text_value_15[64];
2445
axis2_char_t *text_value_16;
2446
axis2_char_t *text_value_16_temp;
2448
axis2_char_t *start_input_str = NULL;
2449
axis2_char_t *end_input_str = NULL;
2450
unsigned int start_input_str_len = 0;
2451
unsigned int end_input_str_len = 0;
2454
axiom_data_source_t *data_source = NULL;
2455
axutil_stream_t *stream = NULL;
2459
AXIS2_ENV_CHECK(env, NULL);
2460
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
2463
current_node = parent;
2464
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
2467
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
2471
if(!parent_tag_closed)
2474
string_to_stream = ">";
2475
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
2480
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2482
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2483
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2484
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2486
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2487
"http://eucalyptus.ucsb.edu/",
2492
if (!_instanceType->is_valid_reservationId)
2496
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property reservationId");
2502
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2503
(4 + axutil_strlen(p_prefix) +
2504
axutil_strlen("reservationId")));
2506
/* axutil_strlen("<:>") + 1 = 4 */
2507
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2508
(5 + axutil_strlen(p_prefix) + axutil_strlen("reservationId")));
2509
/* axutil_strlen("</:>") + 1 = 5 */
2517
* parsing reservationId element
2522
sprintf(start_input_str, "<%s%sreservationId>",
2523
p_prefix?p_prefix:"",
2524
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2526
start_input_str_len = axutil_strlen(start_input_str);
2527
sprintf(end_input_str, "</%s%sreservationId>",
2528
p_prefix?p_prefix:"",
2529
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2530
end_input_str_len = axutil_strlen(end_input_str);
2532
text_value_1 = _instanceType->property_reservationId;
2534
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2537
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
2538
if (text_value_1_temp)
2540
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
2541
AXIS2_FREE(env->allocator, text_value_1_temp);
2545
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
2548
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2551
AXIS2_FREE(env->allocator,start_input_str);
2552
AXIS2_FREE(env->allocator,end_input_str);
2556
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2558
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2559
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2560
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2562
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2563
"http://eucalyptus.ucsb.edu/",
2568
if (!_instanceType->is_valid_instanceId)
2572
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property instanceId");
2578
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2579
(4 + axutil_strlen(p_prefix) +
2580
axutil_strlen("instanceId")));
2582
/* axutil_strlen("<:>") + 1 = 4 */
2583
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2584
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceId")));
2585
/* axutil_strlen("</:>") + 1 = 5 */
2593
* parsing instanceId element
2598
sprintf(start_input_str, "<%s%sinstanceId>",
2599
p_prefix?p_prefix:"",
2600
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2602
start_input_str_len = axutil_strlen(start_input_str);
2603
sprintf(end_input_str, "</%s%sinstanceId>",
2604
p_prefix?p_prefix:"",
2605
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2606
end_input_str_len = axutil_strlen(end_input_str);
2608
text_value_2 = _instanceType->property_instanceId;
2610
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2613
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
2614
if (text_value_2_temp)
2616
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
2617
AXIS2_FREE(env->allocator, text_value_2_temp);
2621
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
2624
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2627
AXIS2_FREE(env->allocator,start_input_str);
2628
AXIS2_FREE(env->allocator,end_input_str);
2632
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2634
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2635
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2636
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2638
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2639
"http://eucalyptus.ucsb.edu/",
2644
if (!_instanceType->is_valid_imageId)
2648
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property imageId");
2654
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2655
(4 + axutil_strlen(p_prefix) +
2656
axutil_strlen("imageId")));
2658
/* axutil_strlen("<:>") + 1 = 4 */
2659
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2660
(5 + axutil_strlen(p_prefix) + axutil_strlen("imageId")));
2661
/* axutil_strlen("</:>") + 1 = 5 */
2669
* parsing imageId element
2674
sprintf(start_input_str, "<%s%simageId>",
2675
p_prefix?p_prefix:"",
2676
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2678
start_input_str_len = axutil_strlen(start_input_str);
2679
sprintf(end_input_str, "</%s%simageId>",
2680
p_prefix?p_prefix:"",
2681
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2682
end_input_str_len = axutil_strlen(end_input_str);
2684
text_value_3 = _instanceType->property_imageId;
2686
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2689
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
2690
if (text_value_3_temp)
2692
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
2693
AXIS2_FREE(env->allocator, text_value_3_temp);
2697
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
2700
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2703
AXIS2_FREE(env->allocator,start_input_str);
2704
AXIS2_FREE(env->allocator,end_input_str);
2708
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2710
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2711
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2712
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2714
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2715
"http://eucalyptus.ucsb.edu/",
2720
if (!_instanceType->is_valid_kernelId)
2724
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property kernelId");
2730
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2731
(4 + axutil_strlen(p_prefix) +
2732
axutil_strlen("kernelId")));
2734
/* axutil_strlen("<:>") + 1 = 4 */
2735
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2736
(5 + axutil_strlen(p_prefix) + axutil_strlen("kernelId")));
2737
/* axutil_strlen("</:>") + 1 = 5 */
2745
* parsing kernelId element
2750
sprintf(start_input_str, "<%s%skernelId>",
2751
p_prefix?p_prefix:"",
2752
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2754
start_input_str_len = axutil_strlen(start_input_str);
2755
sprintf(end_input_str, "</%s%skernelId>",
2756
p_prefix?p_prefix:"",
2757
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2758
end_input_str_len = axutil_strlen(end_input_str);
2760
text_value_4 = _instanceType->property_kernelId;
2762
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2765
text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
2766
if (text_value_4_temp)
2768
axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
2769
AXIS2_FREE(env->allocator, text_value_4_temp);
2773
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
2776
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2779
AXIS2_FREE(env->allocator,start_input_str);
2780
AXIS2_FREE(env->allocator,end_input_str);
2784
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2786
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2787
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2788
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2790
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2791
"http://eucalyptus.ucsb.edu/",
2796
if (!_instanceType->is_valid_ramdiskId)
2799
/* no need to complain for minoccurs=0 element */
2805
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2806
(4 + axutil_strlen(p_prefix) +
2807
axutil_strlen("ramdiskId")));
2809
/* axutil_strlen("<:>") + 1 = 4 */
2810
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2811
(5 + axutil_strlen(p_prefix) + axutil_strlen("ramdiskId")));
2812
/* axutil_strlen("</:>") + 1 = 5 */
2820
* parsing ramdiskId element
2825
sprintf(start_input_str, "<%s%sramdiskId>",
2826
p_prefix?p_prefix:"",
2827
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2829
start_input_str_len = axutil_strlen(start_input_str);
2830
sprintf(end_input_str, "</%s%sramdiskId>",
2831
p_prefix?p_prefix:"",
2832
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2833
end_input_str_len = axutil_strlen(end_input_str);
2835
text_value_5 = _instanceType->property_ramdiskId;
2837
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2840
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
2841
if (text_value_5_temp)
2843
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
2844
AXIS2_FREE(env->allocator, text_value_5_temp);
2848
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
2851
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2854
AXIS2_FREE(env->allocator,start_input_str);
2855
AXIS2_FREE(env->allocator,end_input_str);
2859
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2861
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2862
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2863
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2865
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2866
"http://eucalyptus.ucsb.edu/",
2871
if (!_instanceType->is_valid_userId)
2875
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property userId");
2881
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2882
(4 + axutil_strlen(p_prefix) +
2883
axutil_strlen("userId")));
2885
/* axutil_strlen("<:>") + 1 = 4 */
2886
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2887
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
2888
/* axutil_strlen("</:>") + 1 = 5 */
2896
* parsing userId element
2901
sprintf(start_input_str, "<%s%suserId>",
2902
p_prefix?p_prefix:"",
2903
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2905
start_input_str_len = axutil_strlen(start_input_str);
2906
sprintf(end_input_str, "</%s%suserId>",
2907
p_prefix?p_prefix:"",
2908
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2909
end_input_str_len = axutil_strlen(end_input_str);
2911
text_value_6 = _instanceType->property_userId;
2913
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2916
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
2917
if (text_value_6_temp)
2919
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
2920
AXIS2_FREE(env->allocator, text_value_6_temp);
2924
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
2927
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2930
AXIS2_FREE(env->allocator,start_input_str);
2931
AXIS2_FREE(env->allocator,end_input_str);
2935
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2937
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2938
sprintf(p_prefix, "n%d", (*next_ns_index)++);
2939
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2941
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2942
"http://eucalyptus.ucsb.edu/",
2947
if (!_instanceType->is_valid_keyName)
2951
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property keyName");
2957
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2958
(4 + axutil_strlen(p_prefix) +
2959
axutil_strlen("keyName")));
2961
/* axutil_strlen("<:>") + 1 = 4 */
2962
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2963
(5 + axutil_strlen(p_prefix) + axutil_strlen("keyName")));
2964
/* axutil_strlen("</:>") + 1 = 5 */
2972
* parsing keyName element
2977
sprintf(start_input_str, "<%s%skeyName>",
2978
p_prefix?p_prefix:"",
2979
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2981
start_input_str_len = axutil_strlen(start_input_str);
2982
sprintf(end_input_str, "</%s%skeyName>",
2983
p_prefix?p_prefix:"",
2984
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2985
end_input_str_len = axutil_strlen(end_input_str);
2987
text_value_7 = _instanceType->property_keyName;
2989
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2992
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
2993
if (text_value_7_temp)
2995
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
2996
AXIS2_FREE(env->allocator, text_value_7_temp);
3000
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
3003
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3006
AXIS2_FREE(env->allocator,start_input_str);
3007
AXIS2_FREE(env->allocator,end_input_str);
3011
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3013
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3014
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3015
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3017
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3018
"http://eucalyptus.ucsb.edu/",
3023
if (!_instanceType->is_valid_instanceType)
3027
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property instanceType");
3033
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3034
(4 + axutil_strlen(p_prefix) +
3035
axutil_strlen("instanceType")));
3037
/* axutil_strlen("<:>") + 1 = 4 */
3038
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3039
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceType")));
3040
/* axutil_strlen("</:>") + 1 = 5 */
3048
* parsing instanceType element
3053
sprintf(start_input_str, "<%s%sinstanceType",
3054
p_prefix?p_prefix:"",
3055
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3057
start_input_str_len = axutil_strlen(start_input_str);
3058
sprintf(end_input_str, "</%s%sinstanceType>",
3059
p_prefix?p_prefix:"",
3060
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3061
end_input_str_len = axutil_strlen(end_input_str);
3063
if(!adb_virtualMachineType_is_particle())
3065
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3068
adb_virtualMachineType_serialize(_instanceType->property_instanceType,
3069
env, current_node, parent_element,
3070
adb_virtualMachineType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
3072
if(!adb_virtualMachineType_is_particle())
3074
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3078
AXIS2_FREE(env->allocator,start_input_str);
3079
AXIS2_FREE(env->allocator,end_input_str);
3083
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3085
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3086
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3087
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3089
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3090
"http://eucalyptus.ucsb.edu/",
3095
if (!_instanceType->is_valid_netParams)
3098
/* no need to complain for minoccurs=0 element */
3104
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3105
(4 + axutil_strlen(p_prefix) +
3106
axutil_strlen("netParams")));
3108
/* axutil_strlen("<:>") + 1 = 4 */
3109
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3110
(5 + axutil_strlen(p_prefix) + axutil_strlen("netParams")));
3111
/* axutil_strlen("</:>") + 1 = 5 */
3119
* parsing netParams element
3124
sprintf(start_input_str, "<%s%snetParams",
3125
p_prefix?p_prefix:"",
3126
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3128
start_input_str_len = axutil_strlen(start_input_str);
3129
sprintf(end_input_str, "</%s%snetParams>",
3130
p_prefix?p_prefix:"",
3131
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3132
end_input_str_len = axutil_strlen(end_input_str);
3134
if(!adb_netConfigType_is_particle())
3136
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3139
adb_netConfigType_serialize(_instanceType->property_netParams,
3140
env, current_node, parent_element,
3141
adb_netConfigType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
3143
if(!adb_netConfigType_is_particle())
3145
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3149
AXIS2_FREE(env->allocator,start_input_str);
3150
AXIS2_FREE(env->allocator,end_input_str);
3154
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3156
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3157
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3158
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3160
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3161
"http://eucalyptus.ucsb.edu/",
3166
if (!_instanceType->is_valid_stateName)
3170
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property stateName");
3176
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3177
(4 + axutil_strlen(p_prefix) +
3178
axutil_strlen("stateName")));
3180
/* axutil_strlen("<:>") + 1 = 4 */
3181
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3182
(5 + axutil_strlen(p_prefix) + axutil_strlen("stateName")));
3183
/* axutil_strlen("</:>") + 1 = 5 */
3191
* parsing stateName element
3196
sprintf(start_input_str, "<%s%sstateName>",
3197
p_prefix?p_prefix:"",
3198
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3200
start_input_str_len = axutil_strlen(start_input_str);
3201
sprintf(end_input_str, "</%s%sstateName>",
3202
p_prefix?p_prefix:"",
3203
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3204
end_input_str_len = axutil_strlen(end_input_str);
3206
text_value_10 = _instanceType->property_stateName;
3208
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3211
text_value_10_temp = axutil_xml_quote_string(env, text_value_10, AXIS2_TRUE);
3212
if (text_value_10_temp)
3214
axutil_stream_write(stream, env, text_value_10_temp, axutil_strlen(text_value_10_temp));
3215
AXIS2_FREE(env->allocator, text_value_10_temp);
3219
axutil_stream_write(stream, env, text_value_10, axutil_strlen(text_value_10));
3222
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3225
AXIS2_FREE(env->allocator,start_input_str);
3226
AXIS2_FREE(env->allocator,end_input_str);
3230
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3232
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3233
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3234
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3236
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3237
"http://eucalyptus.ucsb.edu/",
3242
if (!_instanceType->is_valid_launchTime)
3245
/* no need to complain for minoccurs=0 element */
3251
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3252
(4 + axutil_strlen(p_prefix) +
3253
axutil_strlen("launchTime")));
3255
/* axutil_strlen("<:>") + 1 = 4 */
3256
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3257
(5 + axutil_strlen(p_prefix) + axutil_strlen("launchTime")));
3258
/* axutil_strlen("</:>") + 1 = 5 */
3266
* parsing launchTime element
3271
sprintf(start_input_str, "<%s%slaunchTime>",
3272
p_prefix?p_prefix:"",
3273
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3275
start_input_str_len = axutil_strlen(start_input_str);
3276
sprintf(end_input_str, "</%s%slaunchTime>",
3277
p_prefix?p_prefix:"",
3278
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3279
end_input_str_len = axutil_strlen(end_input_str);
3281
text_value_11 = axutil_date_time_serialize_date_time(_instanceType->property_launchTime, env);
3283
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3285
axutil_stream_write(stream, env, text_value_11, axutil_strlen(text_value_11));
3287
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3290
AXIS2_FREE(env->allocator,start_input_str);
3291
AXIS2_FREE(env->allocator,end_input_str);
3295
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3297
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3298
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3299
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3301
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3302
"http://eucalyptus.ucsb.edu/",
3307
if (!_instanceType->is_valid_userData)
3310
/* no need to complain for minoccurs=0 element */
3316
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3317
(4 + axutil_strlen(p_prefix) +
3318
axutil_strlen("userData")));
3320
/* axutil_strlen("<:>") + 1 = 4 */
3321
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3322
(5 + axutil_strlen(p_prefix) + axutil_strlen("userData")));
3323
/* axutil_strlen("</:>") + 1 = 5 */
3331
* parsing userData element
3336
sprintf(start_input_str, "<%s%suserData>",
3337
p_prefix?p_prefix:"",
3338
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3340
start_input_str_len = axutil_strlen(start_input_str);
3341
sprintf(end_input_str, "</%s%suserData>",
3342
p_prefix?p_prefix:"",
3343
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3344
end_input_str_len = axutil_strlen(end_input_str);
3346
text_value_12 = _instanceType->property_userData;
3348
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3351
text_value_12_temp = axutil_xml_quote_string(env, text_value_12, AXIS2_TRUE);
3352
if (text_value_12_temp)
3354
axutil_stream_write(stream, env, text_value_12_temp, axutil_strlen(text_value_12_temp));
3355
AXIS2_FREE(env->allocator, text_value_12_temp);
3359
axutil_stream_write(stream, env, text_value_12, axutil_strlen(text_value_12));
3362
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3365
AXIS2_FREE(env->allocator,start_input_str);
3366
AXIS2_FREE(env->allocator,end_input_str);
3370
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3372
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3373
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3374
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3376
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3377
"http://eucalyptus.ucsb.edu/",
3382
if (!_instanceType->is_valid_launchIndex)
3385
/* no need to complain for minoccurs=0 element */
3391
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3392
(4 + axutil_strlen(p_prefix) +
3393
axutil_strlen("launchIndex")));
3395
/* axutil_strlen("<:>") + 1 = 4 */
3396
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3397
(5 + axutil_strlen(p_prefix) + axutil_strlen("launchIndex")));
3398
/* axutil_strlen("</:>") + 1 = 5 */
3406
* parsing launchIndex element
3411
sprintf(start_input_str, "<%s%slaunchIndex>",
3412
p_prefix?p_prefix:"",
3413
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3415
start_input_str_len = axutil_strlen(start_input_str);
3416
sprintf(end_input_str, "</%s%slaunchIndex>",
3417
p_prefix?p_prefix:"",
3418
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3419
end_input_str_len = axutil_strlen(end_input_str);
3421
text_value_13 = _instanceType->property_launchIndex;
3423
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3426
text_value_13_temp = axutil_xml_quote_string(env, text_value_13, AXIS2_TRUE);
3427
if (text_value_13_temp)
3429
axutil_stream_write(stream, env, text_value_13_temp, axutil_strlen(text_value_13_temp));
3430
AXIS2_FREE(env->allocator, text_value_13_temp);
3434
axutil_stream_write(stream, env, text_value_13, axutil_strlen(text_value_13));
3437
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3440
AXIS2_FREE(env->allocator,start_input_str);
3441
AXIS2_FREE(env->allocator,end_input_str);
3445
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3447
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3448
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3449
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3451
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3452
"http://eucalyptus.ucsb.edu/",
3457
if (!_instanceType->is_valid_groupNames)
3460
/* no need to complain for minoccurs=0 element */
3466
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3467
(4 + axutil_strlen(p_prefix) +
3468
axutil_strlen("groupNames")));
3470
/* axutil_strlen("<:>") + 1 = 4 */
3471
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3472
(5 + axutil_strlen(p_prefix) + axutil_strlen("groupNames")));
3473
/* axutil_strlen("</:>") + 1 = 5 */
3480
* Parsing groupNames array
3482
if (_instanceType->property_groupNames != NULL)
3485
sprintf(start_input_str, "<%s%sgroupNames>",
3486
p_prefix?p_prefix:"",
3487
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3489
start_input_str_len = axutil_strlen(start_input_str);
3491
sprintf(end_input_str, "</%s%sgroupNames>",
3492
p_prefix?p_prefix:"",
3493
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3494
end_input_str_len = axutil_strlen(end_input_str);
3496
count = axutil_array_list_size(_instanceType->property_groupNames, env);
3497
for(i = 0; i < count; i ++)
3499
element = axutil_array_list_get(_instanceType->property_groupNames, env, i);
3508
* parsing groupNames element
3513
text_value_14 = (axis2_char_t*)element;
3515
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3518
text_value_14_temp = axutil_xml_quote_string(env, text_value_14, AXIS2_TRUE);
3519
if (text_value_14_temp)
3521
axutil_stream_write(stream, env, text_value_14_temp, axutil_strlen(text_value_14_temp));
3522
AXIS2_FREE(env->allocator, text_value_14_temp);
3526
axutil_stream_write(stream, env, text_value_14, axutil_strlen(text_value_14));
3529
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3535
AXIS2_FREE(env->allocator,start_input_str);
3536
AXIS2_FREE(env->allocator,end_input_str);
3540
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3542
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3543
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3544
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3546
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3547
"http://eucalyptus.ucsb.edu/",
3552
if (!_instanceType->is_valid_volumes)
3555
/* no need to complain for minoccurs=0 element */
3561
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3562
(4 + axutil_strlen(p_prefix) +
3563
axutil_strlen("volumes")));
3565
/* axutil_strlen("<:>") + 1 = 4 */
3566
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3567
(5 + axutil_strlen(p_prefix) + axutil_strlen("volumes")));
3568
/* axutil_strlen("</:>") + 1 = 5 */
3575
* Parsing volumes array
3577
if (_instanceType->property_volumes != NULL)
3581
sprintf(start_input_str, "<%s%svolumes",
3582
p_prefix?p_prefix:"",
3583
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3585
start_input_str_len = axutil_strlen(start_input_str);
3587
sprintf(end_input_str, "</%s%svolumes>",
3588
p_prefix?p_prefix:"",
3589
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3590
end_input_str_len = axutil_strlen(end_input_str);
3592
count = axutil_array_list_size(_instanceType->property_volumes, env);
3593
for(i = 0; i < count; i ++)
3595
element = axutil_array_list_get(_instanceType->property_volumes, env, i);
3604
* parsing volumes element
3609
if(!adb_volumeType_is_particle())
3611
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3614
adb_volumeType_serialize((adb_volumeType_t*)element,
3615
env, current_node, parent_element,
3616
adb_volumeType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
3618
if(!adb_volumeType_is_particle())
3620
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3627
AXIS2_FREE(env->allocator,start_input_str);
3628
AXIS2_FREE(env->allocator,end_input_str);
3632
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
3634
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
3635
sprintf(p_prefix, "n%d", (*next_ns_index)++);
3636
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
3638
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
3639
"http://eucalyptus.ucsb.edu/",
3644
if (!_instanceType->is_valid_serviceTag)
3647
/* no need to complain for minoccurs=0 element */
3653
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3654
(4 + axutil_strlen(p_prefix) +
3655
axutil_strlen("serviceTag")));
3657
/* axutil_strlen("<:>") + 1 = 4 */
3658
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
3659
(5 + axutil_strlen(p_prefix) + axutil_strlen("serviceTag")));
3660
/* axutil_strlen("</:>") + 1 = 5 */
3668
* parsing serviceTag element
3673
sprintf(start_input_str, "<%s%sserviceTag>",
3674
p_prefix?p_prefix:"",
3675
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3677
start_input_str_len = axutil_strlen(start_input_str);
3678
sprintf(end_input_str, "</%s%sserviceTag>",
3679
p_prefix?p_prefix:"",
3680
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
3681
end_input_str_len = axutil_strlen(end_input_str);
3683
text_value_16 = _instanceType->property_serviceTag;
3685
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
3688
text_value_16_temp = axutil_xml_quote_string(env, text_value_16, AXIS2_TRUE);
3689
if (text_value_16_temp)
3691
axutil_stream_write(stream, env, text_value_16_temp, axutil_strlen(text_value_16_temp));
3692
AXIS2_FREE(env->allocator, text_value_16_temp);
3696
axutil_stream_write(stream, env, text_value_16, axutil_strlen(text_value_16));
3699
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
3702
AXIS2_FREE(env->allocator,start_input_str);
3703
AXIS2_FREE(env->allocator,end_input_str);
3715
* getter for reservationId.
3717
axis2_char_t* AXIS2_CALL
3718
adb_instanceType_get_reservationId(
3719
adb_instanceType_t* _instanceType,
3720
const axutil_env_t *env)
3723
AXIS2_ENV_CHECK(env, NULL);
3724
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
3727
return _instanceType->property_reservationId;
3731
* setter for reservationId
3733
axis2_status_t AXIS2_CALL
3734
adb_instanceType_set_reservationId(
3735
adb_instanceType_t* _instanceType,
3736
const axutil_env_t *env,
3737
const axis2_char_t* arg_reservationId)
3741
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3742
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
3744
if(_instanceType->is_valid_reservationId &&
3745
arg_reservationId == _instanceType->property_reservationId)
3748
return AXIS2_SUCCESS;
3752
if(NULL == arg_reservationId)
3754
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "reservationId is being set to NULL, but it is not a nullable element");
3755
return AXIS2_FAILURE;
3757
adb_instanceType_reset_reservationId(_instanceType, env);
3760
if(NULL == arg_reservationId)
3762
/* We are already done */
3763
return AXIS2_SUCCESS;
3765
_instanceType->property_reservationId = (axis2_char_t *)axutil_strdup(env, arg_reservationId);
3766
if(NULL == _instanceType->property_reservationId)
3768
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for reservationId");
3769
return AXIS2_FAILURE;
3771
_instanceType->is_valid_reservationId = AXIS2_TRUE;
3773
return AXIS2_SUCCESS;
3779
* resetter for reservationId
3781
axis2_status_t AXIS2_CALL
3782
adb_instanceType_reset_reservationId(
3783
adb_instanceType_t* _instanceType,
3784
const axutil_env_t *env)
3788
void *element = NULL;
3790
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3791
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
3797
if(_instanceType->property_reservationId != NULL)
3801
AXIS2_FREE(env-> allocator, _instanceType->property_reservationId);
3802
_instanceType->property_reservationId = NULL;
3807
_instanceType->is_valid_reservationId = AXIS2_FALSE;
3808
return AXIS2_SUCCESS;
3812
* Check whether reservationId is nill
3814
axis2_bool_t AXIS2_CALL
3815
adb_instanceType_is_reservationId_nil(
3816
adb_instanceType_t* _instanceType,
3817
const axutil_env_t *env)
3819
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3820
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
3822
return !_instanceType->is_valid_reservationId;
3826
* Set reservationId to nill (currently the same as reset)
3828
axis2_status_t AXIS2_CALL
3829
adb_instanceType_set_reservationId_nil(
3830
adb_instanceType_t* _instanceType,
3831
const axutil_env_t *env)
3833
return adb_instanceType_reset_reservationId(_instanceType, env);
3839
* getter for instanceId.
3841
axis2_char_t* AXIS2_CALL
3842
adb_instanceType_get_instanceId(
3843
adb_instanceType_t* _instanceType,
3844
const axutil_env_t *env)
3847
AXIS2_ENV_CHECK(env, NULL);
3848
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
3851
return _instanceType->property_instanceId;
3855
* setter for instanceId
3857
axis2_status_t AXIS2_CALL
3858
adb_instanceType_set_instanceId(
3859
adb_instanceType_t* _instanceType,
3860
const axutil_env_t *env,
3861
const axis2_char_t* arg_instanceId)
3865
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3866
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
3868
if(_instanceType->is_valid_instanceId &&
3869
arg_instanceId == _instanceType->property_instanceId)
3872
return AXIS2_SUCCESS;
3876
if(NULL == arg_instanceId)
3878
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceId is being set to NULL, but it is not a nullable element");
3879
return AXIS2_FAILURE;
3881
adb_instanceType_reset_instanceId(_instanceType, env);
3884
if(NULL == arg_instanceId)
3886
/* We are already done */
3887
return AXIS2_SUCCESS;
3889
_instanceType->property_instanceId = (axis2_char_t *)axutil_strdup(env, arg_instanceId);
3890
if(NULL == _instanceType->property_instanceId)
3892
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for instanceId");
3893
return AXIS2_FAILURE;
3895
_instanceType->is_valid_instanceId = AXIS2_TRUE;
3897
return AXIS2_SUCCESS;
3903
* resetter for instanceId
3905
axis2_status_t AXIS2_CALL
3906
adb_instanceType_reset_instanceId(
3907
adb_instanceType_t* _instanceType,
3908
const axutil_env_t *env)
3912
void *element = NULL;
3914
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3915
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
3921
if(_instanceType->property_instanceId != NULL)
3925
AXIS2_FREE(env-> allocator, _instanceType->property_instanceId);
3926
_instanceType->property_instanceId = NULL;
3931
_instanceType->is_valid_instanceId = AXIS2_FALSE;
3932
return AXIS2_SUCCESS;
3936
* Check whether instanceId is nill
3938
axis2_bool_t AXIS2_CALL
3939
adb_instanceType_is_instanceId_nil(
3940
adb_instanceType_t* _instanceType,
3941
const axutil_env_t *env)
3943
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3944
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
3946
return !_instanceType->is_valid_instanceId;
3950
* Set instanceId to nill (currently the same as reset)
3952
axis2_status_t AXIS2_CALL
3953
adb_instanceType_set_instanceId_nil(
3954
adb_instanceType_t* _instanceType,
3955
const axutil_env_t *env)
3957
return adb_instanceType_reset_instanceId(_instanceType, env);
3963
* getter for imageId.
3965
axis2_char_t* AXIS2_CALL
3966
adb_instanceType_get_imageId(
3967
adb_instanceType_t* _instanceType,
3968
const axutil_env_t *env)
3971
AXIS2_ENV_CHECK(env, NULL);
3972
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
3975
return _instanceType->property_imageId;
3979
* setter for imageId
3981
axis2_status_t AXIS2_CALL
3982
adb_instanceType_set_imageId(
3983
adb_instanceType_t* _instanceType,
3984
const axutil_env_t *env,
3985
const axis2_char_t* arg_imageId)
3989
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3990
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
3992
if(_instanceType->is_valid_imageId &&
3993
arg_imageId == _instanceType->property_imageId)
3996
return AXIS2_SUCCESS;
4000
if(NULL == arg_imageId)
4002
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "imageId is being set to NULL, but it is not a nullable element");
4003
return AXIS2_FAILURE;
4005
adb_instanceType_reset_imageId(_instanceType, env);
4008
if(NULL == arg_imageId)
4010
/* We are already done */
4011
return AXIS2_SUCCESS;
4013
_instanceType->property_imageId = (axis2_char_t *)axutil_strdup(env, arg_imageId);
4014
if(NULL == _instanceType->property_imageId)
4016
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for imageId");
4017
return AXIS2_FAILURE;
4019
_instanceType->is_valid_imageId = AXIS2_TRUE;
4021
return AXIS2_SUCCESS;
4027
* resetter for imageId
4029
axis2_status_t AXIS2_CALL
4030
adb_instanceType_reset_imageId(
4031
adb_instanceType_t* _instanceType,
4032
const axutil_env_t *env)
4036
void *element = NULL;
4038
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4039
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4045
if(_instanceType->property_imageId != NULL)
4049
AXIS2_FREE(env-> allocator, _instanceType->property_imageId);
4050
_instanceType->property_imageId = NULL;
4055
_instanceType->is_valid_imageId = AXIS2_FALSE;
4056
return AXIS2_SUCCESS;
4060
* Check whether imageId is nill
4062
axis2_bool_t AXIS2_CALL
4063
adb_instanceType_is_imageId_nil(
4064
adb_instanceType_t* _instanceType,
4065
const axutil_env_t *env)
4067
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4068
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4070
return !_instanceType->is_valid_imageId;
4074
* Set imageId to nill (currently the same as reset)
4076
axis2_status_t AXIS2_CALL
4077
adb_instanceType_set_imageId_nil(
4078
adb_instanceType_t* _instanceType,
4079
const axutil_env_t *env)
4081
return adb_instanceType_reset_imageId(_instanceType, env);
4087
* getter for kernelId.
4089
axis2_char_t* AXIS2_CALL
4090
adb_instanceType_get_kernelId(
4091
adb_instanceType_t* _instanceType,
4092
const axutil_env_t *env)
4095
AXIS2_ENV_CHECK(env, NULL);
4096
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4099
return _instanceType->property_kernelId;
4103
* setter for kernelId
4105
axis2_status_t AXIS2_CALL
4106
adb_instanceType_set_kernelId(
4107
adb_instanceType_t* _instanceType,
4108
const axutil_env_t *env,
4109
const axis2_char_t* arg_kernelId)
4113
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4114
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4116
if(_instanceType->is_valid_kernelId &&
4117
arg_kernelId == _instanceType->property_kernelId)
4120
return AXIS2_SUCCESS;
4124
if(NULL == arg_kernelId)
4126
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "kernelId is being set to NULL, but it is not a nullable element");
4127
return AXIS2_FAILURE;
4129
adb_instanceType_reset_kernelId(_instanceType, env);
4132
if(NULL == arg_kernelId)
4134
/* We are already done */
4135
return AXIS2_SUCCESS;
4137
_instanceType->property_kernelId = (axis2_char_t *)axutil_strdup(env, arg_kernelId);
4138
if(NULL == _instanceType->property_kernelId)
4140
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for kernelId");
4141
return AXIS2_FAILURE;
4143
_instanceType->is_valid_kernelId = AXIS2_TRUE;
4145
return AXIS2_SUCCESS;
4151
* resetter for kernelId
4153
axis2_status_t AXIS2_CALL
4154
adb_instanceType_reset_kernelId(
4155
adb_instanceType_t* _instanceType,
4156
const axutil_env_t *env)
4160
void *element = NULL;
4162
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4163
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4169
if(_instanceType->property_kernelId != NULL)
4173
AXIS2_FREE(env-> allocator, _instanceType->property_kernelId);
4174
_instanceType->property_kernelId = NULL;
4179
_instanceType->is_valid_kernelId = AXIS2_FALSE;
4180
return AXIS2_SUCCESS;
4184
* Check whether kernelId is nill
4186
axis2_bool_t AXIS2_CALL
4187
adb_instanceType_is_kernelId_nil(
4188
adb_instanceType_t* _instanceType,
4189
const axutil_env_t *env)
4191
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4192
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4194
return !_instanceType->is_valid_kernelId;
4198
* Set kernelId to nill (currently the same as reset)
4200
axis2_status_t AXIS2_CALL
4201
adb_instanceType_set_kernelId_nil(
4202
adb_instanceType_t* _instanceType,
4203
const axutil_env_t *env)
4205
return adb_instanceType_reset_kernelId(_instanceType, env);
4211
* getter for ramdiskId.
4213
axis2_char_t* AXIS2_CALL
4214
adb_instanceType_get_ramdiskId(
4215
adb_instanceType_t* _instanceType,
4216
const axutil_env_t *env)
4219
AXIS2_ENV_CHECK(env, NULL);
4220
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4223
return _instanceType->property_ramdiskId;
4227
* setter for ramdiskId
4229
axis2_status_t AXIS2_CALL
4230
adb_instanceType_set_ramdiskId(
4231
adb_instanceType_t* _instanceType,
4232
const axutil_env_t *env,
4233
const axis2_char_t* arg_ramdiskId)
4237
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4238
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4240
if(_instanceType->is_valid_ramdiskId &&
4241
arg_ramdiskId == _instanceType->property_ramdiskId)
4244
return AXIS2_SUCCESS;
4247
adb_instanceType_reset_ramdiskId(_instanceType, env);
4250
if(NULL == arg_ramdiskId)
4252
/* We are already done */
4253
return AXIS2_SUCCESS;
4255
_instanceType->property_ramdiskId = (axis2_char_t *)axutil_strdup(env, arg_ramdiskId);
4256
if(NULL == _instanceType->property_ramdiskId)
4258
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for ramdiskId");
4259
return AXIS2_FAILURE;
4261
_instanceType->is_valid_ramdiskId = AXIS2_TRUE;
4263
return AXIS2_SUCCESS;
4269
* resetter for ramdiskId
4271
axis2_status_t AXIS2_CALL
4272
adb_instanceType_reset_ramdiskId(
4273
adb_instanceType_t* _instanceType,
4274
const axutil_env_t *env)
4278
void *element = NULL;
4280
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4281
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4287
if(_instanceType->property_ramdiskId != NULL)
4291
AXIS2_FREE(env-> allocator, _instanceType->property_ramdiskId);
4292
_instanceType->property_ramdiskId = NULL;
4297
_instanceType->is_valid_ramdiskId = AXIS2_FALSE;
4298
return AXIS2_SUCCESS;
4302
* Check whether ramdiskId is nill
4304
axis2_bool_t AXIS2_CALL
4305
adb_instanceType_is_ramdiskId_nil(
4306
adb_instanceType_t* _instanceType,
4307
const axutil_env_t *env)
4309
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4310
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4312
return !_instanceType->is_valid_ramdiskId;
4316
* Set ramdiskId to nill (currently the same as reset)
4318
axis2_status_t AXIS2_CALL
4319
adb_instanceType_set_ramdiskId_nil(
4320
adb_instanceType_t* _instanceType,
4321
const axutil_env_t *env)
4323
return adb_instanceType_reset_ramdiskId(_instanceType, env);
4329
* getter for userId.
4331
axis2_char_t* AXIS2_CALL
4332
adb_instanceType_get_userId(
4333
adb_instanceType_t* _instanceType,
4334
const axutil_env_t *env)
4337
AXIS2_ENV_CHECK(env, NULL);
4338
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4341
return _instanceType->property_userId;
4347
axis2_status_t AXIS2_CALL
4348
adb_instanceType_set_userId(
4349
adb_instanceType_t* _instanceType,
4350
const axutil_env_t *env,
4351
const axis2_char_t* arg_userId)
4355
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4356
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4358
if(_instanceType->is_valid_userId &&
4359
arg_userId == _instanceType->property_userId)
4362
return AXIS2_SUCCESS;
4366
if(NULL == arg_userId)
4368
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "userId is being set to NULL, but it is not a nullable element");
4369
return AXIS2_FAILURE;
4371
adb_instanceType_reset_userId(_instanceType, env);
4374
if(NULL == arg_userId)
4376
/* We are already done */
4377
return AXIS2_SUCCESS;
4379
_instanceType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
4380
if(NULL == _instanceType->property_userId)
4382
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
4383
return AXIS2_FAILURE;
4385
_instanceType->is_valid_userId = AXIS2_TRUE;
4387
return AXIS2_SUCCESS;
4393
* resetter for userId
4395
axis2_status_t AXIS2_CALL
4396
adb_instanceType_reset_userId(
4397
adb_instanceType_t* _instanceType,
4398
const axutil_env_t *env)
4402
void *element = NULL;
4404
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4405
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4411
if(_instanceType->property_userId != NULL)
4415
AXIS2_FREE(env-> allocator, _instanceType->property_userId);
4416
_instanceType->property_userId = NULL;
4421
_instanceType->is_valid_userId = AXIS2_FALSE;
4422
return AXIS2_SUCCESS;
4426
* Check whether userId is nill
4428
axis2_bool_t AXIS2_CALL
4429
adb_instanceType_is_userId_nil(
4430
adb_instanceType_t* _instanceType,
4431
const axutil_env_t *env)
4433
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4434
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4436
return !_instanceType->is_valid_userId;
4440
* Set userId to nill (currently the same as reset)
4442
axis2_status_t AXIS2_CALL
4443
adb_instanceType_set_userId_nil(
4444
adb_instanceType_t* _instanceType,
4445
const axutil_env_t *env)
4447
return adb_instanceType_reset_userId(_instanceType, env);
4453
* getter for keyName.
4455
axis2_char_t* AXIS2_CALL
4456
adb_instanceType_get_keyName(
4457
adb_instanceType_t* _instanceType,
4458
const axutil_env_t *env)
4461
AXIS2_ENV_CHECK(env, NULL);
4462
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4465
return _instanceType->property_keyName;
4469
* setter for keyName
4471
axis2_status_t AXIS2_CALL
4472
adb_instanceType_set_keyName(
4473
adb_instanceType_t* _instanceType,
4474
const axutil_env_t *env,
4475
const axis2_char_t* arg_keyName)
4479
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4480
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4482
if(_instanceType->is_valid_keyName &&
4483
arg_keyName == _instanceType->property_keyName)
4486
return AXIS2_SUCCESS;
4490
if(NULL == arg_keyName)
4492
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "keyName is being set to NULL, but it is not a nullable element");
4493
return AXIS2_FAILURE;
4495
adb_instanceType_reset_keyName(_instanceType, env);
4498
if(NULL == arg_keyName)
4500
/* We are already done */
4501
return AXIS2_SUCCESS;
4503
_instanceType->property_keyName = (axis2_char_t *)axutil_strdup(env, arg_keyName);
4504
if(NULL == _instanceType->property_keyName)
4506
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for keyName");
4507
return AXIS2_FAILURE;
4509
_instanceType->is_valid_keyName = AXIS2_TRUE;
4511
return AXIS2_SUCCESS;
4517
* resetter for keyName
4519
axis2_status_t AXIS2_CALL
4520
adb_instanceType_reset_keyName(
4521
adb_instanceType_t* _instanceType,
4522
const axutil_env_t *env)
4526
void *element = NULL;
4528
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4529
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4535
if(_instanceType->property_keyName != NULL)
4539
AXIS2_FREE(env-> allocator, _instanceType->property_keyName);
4540
_instanceType->property_keyName = NULL;
4545
_instanceType->is_valid_keyName = AXIS2_FALSE;
4546
return AXIS2_SUCCESS;
4550
* Check whether keyName is nill
4552
axis2_bool_t AXIS2_CALL
4553
adb_instanceType_is_keyName_nil(
4554
adb_instanceType_t* _instanceType,
4555
const axutil_env_t *env)
4557
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4558
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4560
return !_instanceType->is_valid_keyName;
4564
* Set keyName to nill (currently the same as reset)
4566
axis2_status_t AXIS2_CALL
4567
adb_instanceType_set_keyName_nil(
4568
adb_instanceType_t* _instanceType,
4569
const axutil_env_t *env)
4571
return adb_instanceType_reset_keyName(_instanceType, env);
4577
* getter for instanceType.
4579
adb_virtualMachineType_t* AXIS2_CALL
4580
adb_instanceType_get_instanceType(
4581
adb_instanceType_t* _instanceType,
4582
const axutil_env_t *env)
4585
AXIS2_ENV_CHECK(env, NULL);
4586
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4589
return _instanceType->property_instanceType;
4593
* setter for instanceType
4595
axis2_status_t AXIS2_CALL
4596
adb_instanceType_set_instanceType(
4597
adb_instanceType_t* _instanceType,
4598
const axutil_env_t *env,
4599
adb_virtualMachineType_t* arg_instanceType)
4603
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4604
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4606
if(_instanceType->is_valid_instanceType &&
4607
arg_instanceType == _instanceType->property_instanceType)
4610
return AXIS2_SUCCESS;
4614
if(NULL == arg_instanceType)
4616
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceType is being set to NULL, but it is not a nullable element");
4617
return AXIS2_FAILURE;
4619
adb_instanceType_reset_instanceType(_instanceType, env);
4622
if(NULL == arg_instanceType)
4624
/* We are already done */
4625
return AXIS2_SUCCESS;
4627
_instanceType->property_instanceType = arg_instanceType;
4628
_instanceType->is_valid_instanceType = AXIS2_TRUE;
4630
return AXIS2_SUCCESS;
4636
* resetter for instanceType
4638
axis2_status_t AXIS2_CALL
4639
adb_instanceType_reset_instanceType(
4640
adb_instanceType_t* _instanceType,
4641
const axutil_env_t *env)
4645
void *element = NULL;
4647
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4648
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4654
if(_instanceType->property_instanceType != NULL)
4658
adb_virtualMachineType_free(_instanceType->property_instanceType, env);
4659
_instanceType->property_instanceType = NULL;
4664
_instanceType->is_valid_instanceType = AXIS2_FALSE;
4665
return AXIS2_SUCCESS;
4669
* Check whether instanceType is nill
4671
axis2_bool_t AXIS2_CALL
4672
adb_instanceType_is_instanceType_nil(
4673
adb_instanceType_t* _instanceType,
4674
const axutil_env_t *env)
4676
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4677
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4679
return !_instanceType->is_valid_instanceType;
4683
* Set instanceType to nill (currently the same as reset)
4685
axis2_status_t AXIS2_CALL
4686
adb_instanceType_set_instanceType_nil(
4687
adb_instanceType_t* _instanceType,
4688
const axutil_env_t *env)
4690
return adb_instanceType_reset_instanceType(_instanceType, env);
4696
* getter for netParams.
4698
adb_netConfigType_t* AXIS2_CALL
4699
adb_instanceType_get_netParams(
4700
adb_instanceType_t* _instanceType,
4701
const axutil_env_t *env)
4704
AXIS2_ENV_CHECK(env, NULL);
4705
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4708
return _instanceType->property_netParams;
4712
* setter for netParams
4714
axis2_status_t AXIS2_CALL
4715
adb_instanceType_set_netParams(
4716
adb_instanceType_t* _instanceType,
4717
const axutil_env_t *env,
4718
adb_netConfigType_t* arg_netParams)
4722
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4723
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4725
if(_instanceType->is_valid_netParams &&
4726
arg_netParams == _instanceType->property_netParams)
4729
return AXIS2_SUCCESS;
4732
adb_instanceType_reset_netParams(_instanceType, env);
4735
if(NULL == arg_netParams)
4737
/* We are already done */
4738
return AXIS2_SUCCESS;
4740
_instanceType->property_netParams = arg_netParams;
4741
_instanceType->is_valid_netParams = AXIS2_TRUE;
4743
return AXIS2_SUCCESS;
4749
* resetter for netParams
4751
axis2_status_t AXIS2_CALL
4752
adb_instanceType_reset_netParams(
4753
adb_instanceType_t* _instanceType,
4754
const axutil_env_t *env)
4758
void *element = NULL;
4760
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4761
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4767
if(_instanceType->property_netParams != NULL)
4771
adb_netConfigType_free(_instanceType->property_netParams, env);
4772
_instanceType->property_netParams = NULL;
4777
_instanceType->is_valid_netParams = AXIS2_FALSE;
4778
return AXIS2_SUCCESS;
4782
* Check whether netParams is nill
4784
axis2_bool_t AXIS2_CALL
4785
adb_instanceType_is_netParams_nil(
4786
adb_instanceType_t* _instanceType,
4787
const axutil_env_t *env)
4789
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4790
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4792
return !_instanceType->is_valid_netParams;
4796
* Set netParams to nill (currently the same as reset)
4798
axis2_status_t AXIS2_CALL
4799
adb_instanceType_set_netParams_nil(
4800
adb_instanceType_t* _instanceType,
4801
const axutil_env_t *env)
4803
return adb_instanceType_reset_netParams(_instanceType, env);
4809
* getter for stateName.
4811
axis2_char_t* AXIS2_CALL
4812
adb_instanceType_get_stateName(
4813
adb_instanceType_t* _instanceType,
4814
const axutil_env_t *env)
4817
AXIS2_ENV_CHECK(env, NULL);
4818
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4821
return _instanceType->property_stateName;
4825
* setter for stateName
4827
axis2_status_t AXIS2_CALL
4828
adb_instanceType_set_stateName(
4829
adb_instanceType_t* _instanceType,
4830
const axutil_env_t *env,
4831
const axis2_char_t* arg_stateName)
4835
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4836
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4838
if(_instanceType->is_valid_stateName &&
4839
arg_stateName == _instanceType->property_stateName)
4842
return AXIS2_SUCCESS;
4846
if(NULL == arg_stateName)
4848
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "stateName is being set to NULL, but it is not a nullable element");
4849
return AXIS2_FAILURE;
4851
adb_instanceType_reset_stateName(_instanceType, env);
4854
if(NULL == arg_stateName)
4856
/* We are already done */
4857
return AXIS2_SUCCESS;
4859
_instanceType->property_stateName = (axis2_char_t *)axutil_strdup(env, arg_stateName);
4860
if(NULL == _instanceType->property_stateName)
4862
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for stateName");
4863
return AXIS2_FAILURE;
4865
_instanceType->is_valid_stateName = AXIS2_TRUE;
4867
return AXIS2_SUCCESS;
4873
* resetter for stateName
4875
axis2_status_t AXIS2_CALL
4876
adb_instanceType_reset_stateName(
4877
adb_instanceType_t* _instanceType,
4878
const axutil_env_t *env)
4882
void *element = NULL;
4884
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4885
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4891
if(_instanceType->property_stateName != NULL)
4895
AXIS2_FREE(env-> allocator, _instanceType->property_stateName);
4896
_instanceType->property_stateName = NULL;
4901
_instanceType->is_valid_stateName = AXIS2_FALSE;
4902
return AXIS2_SUCCESS;
4906
* Check whether stateName is nill
4908
axis2_bool_t AXIS2_CALL
4909
adb_instanceType_is_stateName_nil(
4910
adb_instanceType_t* _instanceType,
4911
const axutil_env_t *env)
4913
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
4914
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
4916
return !_instanceType->is_valid_stateName;
4920
* Set stateName to nill (currently the same as reset)
4922
axis2_status_t AXIS2_CALL
4923
adb_instanceType_set_stateName_nil(
4924
adb_instanceType_t* _instanceType,
4925
const axutil_env_t *env)
4927
return adb_instanceType_reset_stateName(_instanceType, env);
4933
* getter for launchTime.
4935
axutil_date_time_t* AXIS2_CALL
4936
adb_instanceType_get_launchTime(
4937
adb_instanceType_t* _instanceType,
4938
const axutil_env_t *env)
4941
AXIS2_ENV_CHECK(env, NULL);
4942
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
4945
return _instanceType->property_launchTime;
4949
* setter for launchTime
4951
axis2_status_t AXIS2_CALL
4952
adb_instanceType_set_launchTime(
4953
adb_instanceType_t* _instanceType,
4954
const axutil_env_t *env,
4955
axutil_date_time_t* arg_launchTime)
4959
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4960
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
4962
if(_instanceType->is_valid_launchTime &&
4963
arg_launchTime == _instanceType->property_launchTime)
4966
return AXIS2_SUCCESS;
4969
adb_instanceType_reset_launchTime(_instanceType, env);
4972
if(NULL == arg_launchTime)
4974
/* We are already done */
4975
return AXIS2_SUCCESS;
4977
_instanceType->property_launchTime = arg_launchTime;
4978
_instanceType->is_valid_launchTime = AXIS2_TRUE;
4980
return AXIS2_SUCCESS;
4986
* resetter for launchTime
4988
axis2_status_t AXIS2_CALL
4989
adb_instanceType_reset_launchTime(
4990
adb_instanceType_t* _instanceType,
4991
const axutil_env_t *env)
4995
void *element = NULL;
4997
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
4998
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5004
if(_instanceType->property_launchTime != NULL)
5008
axutil_date_time_free(_instanceType->property_launchTime, env);
5009
_instanceType->property_launchTime = NULL;
5014
_instanceType->is_valid_launchTime = AXIS2_FALSE;
5015
return AXIS2_SUCCESS;
5019
* Check whether launchTime is nill
5021
axis2_bool_t AXIS2_CALL
5022
adb_instanceType_is_launchTime_nil(
5023
adb_instanceType_t* _instanceType,
5024
const axutil_env_t *env)
5026
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
5027
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
5029
return !_instanceType->is_valid_launchTime;
5033
* Set launchTime to nill (currently the same as reset)
5035
axis2_status_t AXIS2_CALL
5036
adb_instanceType_set_launchTime_nil(
5037
adb_instanceType_t* _instanceType,
5038
const axutil_env_t *env)
5040
return adb_instanceType_reset_launchTime(_instanceType, env);
5046
* getter for userData.
5048
axis2_char_t* AXIS2_CALL
5049
adb_instanceType_get_userData(
5050
adb_instanceType_t* _instanceType,
5051
const axutil_env_t *env)
5054
AXIS2_ENV_CHECK(env, NULL);
5055
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
5058
return _instanceType->property_userData;
5062
* setter for userData
5064
axis2_status_t AXIS2_CALL
5065
adb_instanceType_set_userData(
5066
adb_instanceType_t* _instanceType,
5067
const axutil_env_t *env,
5068
const axis2_char_t* arg_userData)
5072
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5073
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5075
if(_instanceType->is_valid_userData &&
5076
arg_userData == _instanceType->property_userData)
5079
return AXIS2_SUCCESS;
5082
adb_instanceType_reset_userData(_instanceType, env);
5085
if(NULL == arg_userData)
5087
/* We are already done */
5088
return AXIS2_SUCCESS;
5090
_instanceType->property_userData = (axis2_char_t *)axutil_strdup(env, arg_userData);
5091
if(NULL == _instanceType->property_userData)
5093
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userData");
5094
return AXIS2_FAILURE;
5096
_instanceType->is_valid_userData = AXIS2_TRUE;
5098
return AXIS2_SUCCESS;
5104
* resetter for userData
5106
axis2_status_t AXIS2_CALL
5107
adb_instanceType_reset_userData(
5108
adb_instanceType_t* _instanceType,
5109
const axutil_env_t *env)
5113
void *element = NULL;
5115
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5116
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5122
if(_instanceType->property_userData != NULL)
5126
AXIS2_FREE(env-> allocator, _instanceType->property_userData);
5127
_instanceType->property_userData = NULL;
5132
_instanceType->is_valid_userData = AXIS2_FALSE;
5133
return AXIS2_SUCCESS;
5137
* Check whether userData is nill
5139
axis2_bool_t AXIS2_CALL
5140
adb_instanceType_is_userData_nil(
5141
adb_instanceType_t* _instanceType,
5142
const axutil_env_t *env)
5144
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
5145
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
5147
return !_instanceType->is_valid_userData;
5151
* Set userData to nill (currently the same as reset)
5153
axis2_status_t AXIS2_CALL
5154
adb_instanceType_set_userData_nil(
5155
adb_instanceType_t* _instanceType,
5156
const axutil_env_t *env)
5158
return adb_instanceType_reset_userData(_instanceType, env);
5164
* getter for launchIndex.
5166
axis2_char_t* AXIS2_CALL
5167
adb_instanceType_get_launchIndex(
5168
adb_instanceType_t* _instanceType,
5169
const axutil_env_t *env)
5172
AXIS2_ENV_CHECK(env, NULL);
5173
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
5176
return _instanceType->property_launchIndex;
5180
* setter for launchIndex
5182
axis2_status_t AXIS2_CALL
5183
adb_instanceType_set_launchIndex(
5184
adb_instanceType_t* _instanceType,
5185
const axutil_env_t *env,
5186
const axis2_char_t* arg_launchIndex)
5190
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5191
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5193
if(_instanceType->is_valid_launchIndex &&
5194
arg_launchIndex == _instanceType->property_launchIndex)
5197
return AXIS2_SUCCESS;
5200
adb_instanceType_reset_launchIndex(_instanceType, env);
5203
if(NULL == arg_launchIndex)
5205
/* We are already done */
5206
return AXIS2_SUCCESS;
5208
_instanceType->property_launchIndex = (axis2_char_t *)axutil_strdup(env, arg_launchIndex);
5209
if(NULL == _instanceType->property_launchIndex)
5211
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for launchIndex");
5212
return AXIS2_FAILURE;
5214
_instanceType->is_valid_launchIndex = AXIS2_TRUE;
5216
return AXIS2_SUCCESS;
5222
* resetter for launchIndex
5224
axis2_status_t AXIS2_CALL
5225
adb_instanceType_reset_launchIndex(
5226
adb_instanceType_t* _instanceType,
5227
const axutil_env_t *env)
5231
void *element = NULL;
5233
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5234
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5240
if(_instanceType->property_launchIndex != NULL)
5244
AXIS2_FREE(env-> allocator, _instanceType->property_launchIndex);
5245
_instanceType->property_launchIndex = NULL;
5250
_instanceType->is_valid_launchIndex = AXIS2_FALSE;
5251
return AXIS2_SUCCESS;
5255
* Check whether launchIndex is nill
5257
axis2_bool_t AXIS2_CALL
5258
adb_instanceType_is_launchIndex_nil(
5259
adb_instanceType_t* _instanceType,
5260
const axutil_env_t *env)
5262
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
5263
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
5265
return !_instanceType->is_valid_launchIndex;
5269
* Set launchIndex to nill (currently the same as reset)
5271
axis2_status_t AXIS2_CALL
5272
adb_instanceType_set_launchIndex_nil(
5273
adb_instanceType_t* _instanceType,
5274
const axutil_env_t *env)
5276
return adb_instanceType_reset_launchIndex(_instanceType, env);
5282
* getter for groupNames.
5284
axutil_array_list_t* AXIS2_CALL
5285
adb_instanceType_get_groupNames(
5286
adb_instanceType_t* _instanceType,
5287
const axutil_env_t *env)
5290
AXIS2_ENV_CHECK(env, NULL);
5291
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
5294
return _instanceType->property_groupNames;
5298
* setter for groupNames
5300
axis2_status_t AXIS2_CALL
5301
adb_instanceType_set_groupNames(
5302
adb_instanceType_t* _instanceType,
5303
const axutil_env_t *env,
5304
axutil_array_list_t* arg_groupNames)
5309
axis2_bool_t non_nil_exists = AXIS2_FALSE;
5312
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5313
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5315
if(_instanceType->is_valid_groupNames &&
5316
arg_groupNames == _instanceType->property_groupNames)
5319
return AXIS2_SUCCESS;
5323
size = axutil_array_list_size(arg_groupNames, env);
5327
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "groupNames has exceed the maxOccurs(64)");
5328
return AXIS2_FAILURE;
5333
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "groupNames has less than minOccurs(0)");
5334
return AXIS2_FAILURE;
5336
for(i = 0; i < size; i ++ )
5338
if(NULL != axutil_array_list_get(arg_groupNames, env, i))
5340
non_nil_exists = AXIS2_TRUE;
5345
adb_instanceType_reset_groupNames(_instanceType, env);
5348
if(NULL == arg_groupNames)
5350
/* We are already done */
5351
return AXIS2_SUCCESS;
5353
_instanceType->property_groupNames = arg_groupNames;
5356
_instanceType->is_valid_groupNames = AXIS2_TRUE;
5360
return AXIS2_SUCCESS;
5365
* Get ith element of groupNames.
5367
axis2_char_t* AXIS2_CALL
5368
adb_instanceType_get_groupNames_at(
5369
adb_instanceType_t* _instanceType,
5370
const axutil_env_t *env, int i)
5372
axis2_char_t* ret_val;
5375
AXIS2_ENV_CHECK(env, NULL);
5376
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
5379
if(_instanceType->property_groupNames == NULL)
5381
return (axis2_char_t*)0;
5383
ret_val = (axis2_char_t*)axutil_array_list_get(_instanceType->property_groupNames, env, i);
5390
* Set the ith element of groupNames.
5392
axis2_status_t AXIS2_CALL
5393
adb_instanceType_set_groupNames_at(
5394
adb_instanceType_t* _instanceType,
5395
const axutil_env_t *env, int i,
5396
const axis2_char_t* arg_groupNames)
5398
void *element = NULL;
5402
axis2_bool_t non_nil_exists = AXIS2_FALSE;
5406
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5407
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5409
if( _instanceType->is_valid_groupNames &&
5410
_instanceType->property_groupNames &&
5412
arg_groupNames == (axis2_char_t*)axutil_array_list_get(_instanceType->property_groupNames, env, i))
5416
return AXIS2_SUCCESS;
5420
if(NULL == arg_groupNames)
5422
if(_instanceType->property_groupNames != NULL)
5424
size = axutil_array_list_size(_instanceType->property_groupNames, env);
5425
for(j = 0, k = 0; j < size; j ++ )
5427
if(i == j) continue;
5428
if(NULL != axutil_array_list_get(_instanceType->property_groupNames, env, i))
5431
non_nil_exists = AXIS2_TRUE;
5442
non_nil_exists = AXIS2_TRUE;
5447
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of groupNames is beinng set to be smaller than the specificed number of minOccurs(0)");
5448
return AXIS2_FAILURE;
5451
if(_instanceType->property_groupNames == NULL)
5453
_instanceType->property_groupNames = axutil_array_list_create(env, 10);
5456
/* check whether there already exist an element */
5457
element = axutil_array_list_get(_instanceType->property_groupNames, env, i);
5463
/* This is an unknown type or a primitive. Please free this manually*/
5471
_instanceType->is_valid_groupNames = AXIS2_FALSE;
5472
axutil_array_list_set(_instanceType->property_groupNames , env, i, NULL);
5474
return AXIS2_SUCCESS;
5477
axutil_array_list_set(_instanceType->property_groupNames , env, i, axutil_strdup(env, arg_groupNames));
5478
_instanceType->is_valid_groupNames = AXIS2_TRUE;
5480
return AXIS2_SUCCESS;
5484
* Add to groupNames.
5486
axis2_status_t AXIS2_CALL
5487
adb_instanceType_add_groupNames(
5488
adb_instanceType_t* _instanceType,
5489
const axutil_env_t *env,
5490
const axis2_char_t* arg_groupNames)
5494
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5495
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5498
if(NULL == arg_groupNames)
5501
return AXIS2_SUCCESS;
5506
if(_instanceType->property_groupNames == NULL)
5508
_instanceType->property_groupNames = axutil_array_list_create(env, 10);
5510
if(_instanceType->property_groupNames == NULL)
5512
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for groupNames");
5513
return AXIS2_FAILURE;
5517
axutil_array_list_add(_instanceType->property_groupNames , env, axutil_strdup(env, arg_groupNames));
5518
_instanceType->is_valid_groupNames = AXIS2_TRUE;
5519
return AXIS2_SUCCESS;
5523
* Get the size of the groupNames array.
5526
adb_instanceType_sizeof_groupNames(
5527
adb_instanceType_t* _instanceType,
5528
const axutil_env_t *env)
5530
AXIS2_ENV_CHECK(env, -1);
5531
AXIS2_PARAM_CHECK(env->error, _instanceType, -1);
5532
if(_instanceType->property_groupNames == NULL)
5536
return axutil_array_list_size(_instanceType->property_groupNames, env);
5540
* remove the ith element, same as set_nil_at.
5542
axis2_status_t AXIS2_CALL
5543
adb_instanceType_remove_groupNames_at(
5544
adb_instanceType_t* _instanceType,
5545
const axutil_env_t *env, int i)
5547
return adb_instanceType_set_groupNames_nil_at(_instanceType, env, i);
5553
* resetter for groupNames
5555
axis2_status_t AXIS2_CALL
5556
adb_instanceType_reset_groupNames(
5557
adb_instanceType_t* _instanceType,
5558
const axutil_env_t *env)
5562
void *element = NULL;
5564
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5565
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5569
if (_instanceType->property_groupNames != NULL)
5571
count = axutil_array_list_size(_instanceType->property_groupNames, env);
5572
for(i = 0; i < count; i ++)
5574
element = axutil_array_list_get(_instanceType->property_groupNames, env, i);
5582
AXIS2_FREE(env-> allocator, (axis2_char_t*)element);
5590
axutil_array_list_free(_instanceType->property_groupNames, env);
5592
_instanceType->is_valid_groupNames = AXIS2_FALSE;
5593
return AXIS2_SUCCESS;
5597
* Check whether groupNames is nill
5599
axis2_bool_t AXIS2_CALL
5600
adb_instanceType_is_groupNames_nil(
5601
adb_instanceType_t* _instanceType,
5602
const axutil_env_t *env)
5604
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
5605
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
5607
return !_instanceType->is_valid_groupNames;
5611
* Set groupNames to nill (currently the same as reset)
5613
axis2_status_t AXIS2_CALL
5614
adb_instanceType_set_groupNames_nil(
5615
adb_instanceType_t* _instanceType,
5616
const axutil_env_t *env)
5618
return adb_instanceType_reset_groupNames(_instanceType, env);
5623
* Check whether groupNames is nill at i
5625
axis2_bool_t AXIS2_CALL
5626
adb_instanceType_is_groupNames_nil_at(
5627
adb_instanceType_t* _instanceType,
5628
const axutil_env_t *env, int i)
5630
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
5631
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
5633
return (_instanceType->is_valid_groupNames == AXIS2_FALSE ||
5634
NULL == _instanceType->property_groupNames ||
5635
NULL == axutil_array_list_get(_instanceType->property_groupNames, env, i));
5639
* Set groupNames to nill at i
5641
axis2_status_t AXIS2_CALL
5642
adb_instanceType_set_groupNames_nil_at(
5643
adb_instanceType_t* _instanceType,
5644
const axutil_env_t *env, int i)
5646
void *element = NULL;
5649
axis2_bool_t non_nil_exists = AXIS2_FALSE;
5653
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5654
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5656
if(_instanceType->property_groupNames == NULL ||
5657
_instanceType->is_valid_groupNames == AXIS2_FALSE)
5660
non_nil_exists = AXIS2_FALSE;
5664
size = axutil_array_list_size(_instanceType->property_groupNames, env);
5665
for(j = 0, k = 0; j < size; j ++ )
5667
if(i == j) continue;
5668
if(NULL != axutil_array_list_get(_instanceType->property_groupNames, env, i))
5671
non_nil_exists = AXIS2_TRUE;
5683
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of groupNames is beinng set to be smaller than the specificed number of minOccurs(0)");
5684
return AXIS2_FAILURE;
5687
if(_instanceType->property_groupNames == NULL)
5689
_instanceType->is_valid_groupNames = AXIS2_FALSE;
5691
return AXIS2_SUCCESS;
5694
/* check whether there already exist an element */
5695
element = axutil_array_list_get(_instanceType->property_groupNames, env, i);
5701
/* This is an unknown type or a primitive. Please free this manually*/
5709
_instanceType->is_valid_groupNames = AXIS2_FALSE;
5710
axutil_array_list_set(_instanceType->property_groupNames , env, i, NULL);
5711
return AXIS2_SUCCESS;
5716
axutil_array_list_set(_instanceType->property_groupNames , env, i, NULL);
5718
return AXIS2_SUCCESS;
5725
* getter for volumes.
5727
axutil_array_list_t* AXIS2_CALL
5728
adb_instanceType_get_volumes(
5729
adb_instanceType_t* _instanceType,
5730
const axutil_env_t *env)
5733
AXIS2_ENV_CHECK(env, NULL);
5734
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
5737
return _instanceType->property_volumes;
5741
* setter for volumes
5743
axis2_status_t AXIS2_CALL
5744
adb_instanceType_set_volumes(
5745
adb_instanceType_t* _instanceType,
5746
const axutil_env_t *env,
5747
axutil_array_list_t* arg_volumes)
5752
axis2_bool_t non_nil_exists = AXIS2_FALSE;
5755
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5756
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5758
if(_instanceType->is_valid_volumes &&
5759
arg_volumes == _instanceType->property_volumes)
5762
return AXIS2_SUCCESS;
5766
size = axutil_array_list_size(arg_volumes, env);
5770
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "volumes has exceed the maxOccurs(64)");
5771
return AXIS2_FAILURE;
5776
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "volumes has less than minOccurs(0)");
5777
return AXIS2_FAILURE;
5779
for(i = 0; i < size; i ++ )
5781
if(NULL != axutil_array_list_get(arg_volumes, env, i))
5783
non_nil_exists = AXIS2_TRUE;
5788
adb_instanceType_reset_volumes(_instanceType, env);
5791
if(NULL == arg_volumes)
5793
/* We are already done */
5794
return AXIS2_SUCCESS;
5796
_instanceType->property_volumes = arg_volumes;
5799
_instanceType->is_valid_volumes = AXIS2_TRUE;
5803
return AXIS2_SUCCESS;
5808
* Get ith element of volumes.
5810
adb_volumeType_t* AXIS2_CALL
5811
adb_instanceType_get_volumes_at(
5812
adb_instanceType_t* _instanceType,
5813
const axutil_env_t *env, int i)
5815
adb_volumeType_t* ret_val;
5818
AXIS2_ENV_CHECK(env, NULL);
5819
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
5822
if(_instanceType->property_volumes == NULL)
5824
return (adb_volumeType_t*)0;
5826
ret_val = (adb_volumeType_t*)axutil_array_list_get(_instanceType->property_volumes, env, i);
5833
* Set the ith element of volumes.
5835
axis2_status_t AXIS2_CALL
5836
adb_instanceType_set_volumes_at(
5837
adb_instanceType_t* _instanceType,
5838
const axutil_env_t *env, int i,
5839
adb_volumeType_t* arg_volumes)
5841
void *element = NULL;
5845
axis2_bool_t non_nil_exists = AXIS2_FALSE;
5849
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5850
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5852
if( _instanceType->is_valid_volumes &&
5853
_instanceType->property_volumes &&
5855
arg_volumes == (adb_volumeType_t*)axutil_array_list_get(_instanceType->property_volumes, env, i))
5859
return AXIS2_SUCCESS;
5863
if(NULL == arg_volumes)
5865
if(_instanceType->property_volumes != NULL)
5867
size = axutil_array_list_size(_instanceType->property_volumes, env);
5868
for(j = 0, k = 0; j < size; j ++ )
5870
if(i == j) continue;
5871
if(NULL != axutil_array_list_get(_instanceType->property_volumes, env, i))
5874
non_nil_exists = AXIS2_TRUE;
5885
non_nil_exists = AXIS2_TRUE;
5890
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of volumes is beinng set to be smaller than the specificed number of minOccurs(0)");
5891
return AXIS2_FAILURE;
5894
if(_instanceType->property_volumes == NULL)
5896
_instanceType->property_volumes = axutil_array_list_create(env, 10);
5899
/* check whether there already exist an element */
5900
element = axutil_array_list_get(_instanceType->property_volumes, env, i);
5906
adb_volumeType_free((adb_volumeType_t*)element, env);
5914
_instanceType->is_valid_volumes = AXIS2_FALSE;
5915
axutil_array_list_set(_instanceType->property_volumes , env, i, NULL);
5917
return AXIS2_SUCCESS;
5920
axutil_array_list_set(_instanceType->property_volumes , env, i, arg_volumes);
5921
_instanceType->is_valid_volumes = AXIS2_TRUE;
5923
return AXIS2_SUCCESS;
5929
axis2_status_t AXIS2_CALL
5930
adb_instanceType_add_volumes(
5931
adb_instanceType_t* _instanceType,
5932
const axutil_env_t *env,
5933
adb_volumeType_t* arg_volumes)
5937
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
5938
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
5941
if(NULL == arg_volumes)
5944
return AXIS2_SUCCESS;
5949
if(_instanceType->property_volumes == NULL)
5951
_instanceType->property_volumes = axutil_array_list_create(env, 10);
5953
if(_instanceType->property_volumes == NULL)
5955
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for volumes");
5956
return AXIS2_FAILURE;
5960
axutil_array_list_add(_instanceType->property_volumes , env, arg_volumes);
5961
_instanceType->is_valid_volumes = AXIS2_TRUE;
5962
return AXIS2_SUCCESS;
5966
* Get the size of the volumes array.
5969
adb_instanceType_sizeof_volumes(
5970
adb_instanceType_t* _instanceType,
5971
const axutil_env_t *env)
5973
AXIS2_ENV_CHECK(env, -1);
5974
AXIS2_PARAM_CHECK(env->error, _instanceType, -1);
5975
if(_instanceType->property_volumes == NULL)
5979
return axutil_array_list_size(_instanceType->property_volumes, env);
5983
* remove the ith element, same as set_nil_at.
5985
axis2_status_t AXIS2_CALL
5986
adb_instanceType_remove_volumes_at(
5987
adb_instanceType_t* _instanceType,
5988
const axutil_env_t *env, int i)
5990
return adb_instanceType_set_volumes_nil_at(_instanceType, env, i);
5996
* resetter for volumes
5998
axis2_status_t AXIS2_CALL
5999
adb_instanceType_reset_volumes(
6000
adb_instanceType_t* _instanceType,
6001
const axutil_env_t *env)
6005
void *element = NULL;
6007
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
6008
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
6012
if (_instanceType->property_volumes != NULL)
6014
count = axutil_array_list_size(_instanceType->property_volumes, env);
6015
for(i = 0; i < count; i ++)
6017
element = axutil_array_list_get(_instanceType->property_volumes, env, i);
6025
adb_volumeType_free((adb_volumeType_t*)element, env);
6033
axutil_array_list_free(_instanceType->property_volumes, env);
6035
_instanceType->is_valid_volumes = AXIS2_FALSE;
6036
return AXIS2_SUCCESS;
6040
* Check whether volumes is nill
6042
axis2_bool_t AXIS2_CALL
6043
adb_instanceType_is_volumes_nil(
6044
adb_instanceType_t* _instanceType,
6045
const axutil_env_t *env)
6047
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
6048
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
6050
return !_instanceType->is_valid_volumes;
6054
* Set volumes to nill (currently the same as reset)
6056
axis2_status_t AXIS2_CALL
6057
adb_instanceType_set_volumes_nil(
6058
adb_instanceType_t* _instanceType,
6059
const axutil_env_t *env)
6061
return adb_instanceType_reset_volumes(_instanceType, env);
6066
* Check whether volumes is nill at i
6068
axis2_bool_t AXIS2_CALL
6069
adb_instanceType_is_volumes_nil_at(
6070
adb_instanceType_t* _instanceType,
6071
const axutil_env_t *env, int i)
6073
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
6074
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
6076
return (_instanceType->is_valid_volumes == AXIS2_FALSE ||
6077
NULL == _instanceType->property_volumes ||
6078
NULL == axutil_array_list_get(_instanceType->property_volumes, env, i));
6082
* Set volumes to nill at i
6084
axis2_status_t AXIS2_CALL
6085
adb_instanceType_set_volumes_nil_at(
6086
adb_instanceType_t* _instanceType,
6087
const axutil_env_t *env, int i)
6089
void *element = NULL;
6092
axis2_bool_t non_nil_exists = AXIS2_FALSE;
6096
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
6097
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
6099
if(_instanceType->property_volumes == NULL ||
6100
_instanceType->is_valid_volumes == AXIS2_FALSE)
6103
non_nil_exists = AXIS2_FALSE;
6107
size = axutil_array_list_size(_instanceType->property_volumes, env);
6108
for(j = 0, k = 0; j < size; j ++ )
6110
if(i == j) continue;
6111
if(NULL != axutil_array_list_get(_instanceType->property_volumes, env, i))
6114
non_nil_exists = AXIS2_TRUE;
6126
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of volumes is beinng set to be smaller than the specificed number of minOccurs(0)");
6127
return AXIS2_FAILURE;
6130
if(_instanceType->property_volumes == NULL)
6132
_instanceType->is_valid_volumes = AXIS2_FALSE;
6134
return AXIS2_SUCCESS;
6137
/* check whether there already exist an element */
6138
element = axutil_array_list_get(_instanceType->property_volumes, env, i);
6144
adb_volumeType_free((adb_volumeType_t*)element, env);
6152
_instanceType->is_valid_volumes = AXIS2_FALSE;
6153
axutil_array_list_set(_instanceType->property_volumes , env, i, NULL);
6154
return AXIS2_SUCCESS;
6159
axutil_array_list_set(_instanceType->property_volumes , env, i, NULL);
6161
return AXIS2_SUCCESS;
6168
* getter for serviceTag.
6170
axis2_char_t* AXIS2_CALL
6171
adb_instanceType_get_serviceTag(
6172
adb_instanceType_t* _instanceType,
6173
const axutil_env_t *env)
6176
AXIS2_ENV_CHECK(env, NULL);
6177
AXIS2_PARAM_CHECK(env->error, _instanceType, NULL);
6180
return _instanceType->property_serviceTag;
6184
* setter for serviceTag
6186
axis2_status_t AXIS2_CALL
6187
adb_instanceType_set_serviceTag(
6188
adb_instanceType_t* _instanceType,
6189
const axutil_env_t *env,
6190
const axis2_char_t* arg_serviceTag)
6194
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
6195
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
6197
if(_instanceType->is_valid_serviceTag &&
6198
arg_serviceTag == _instanceType->property_serviceTag)
6201
return AXIS2_SUCCESS;
6204
adb_instanceType_reset_serviceTag(_instanceType, env);
6207
if(NULL == arg_serviceTag)
6209
/* We are already done */
6210
return AXIS2_SUCCESS;
6212
_instanceType->property_serviceTag = (axis2_char_t *)axutil_strdup(env, arg_serviceTag);
6213
if(NULL == _instanceType->property_serviceTag)
6215
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for serviceTag");
6216
return AXIS2_FAILURE;
6218
_instanceType->is_valid_serviceTag = AXIS2_TRUE;
6220
return AXIS2_SUCCESS;
6226
* resetter for serviceTag
6228
axis2_status_t AXIS2_CALL
6229
adb_instanceType_reset_serviceTag(
6230
adb_instanceType_t* _instanceType,
6231
const axutil_env_t *env)
6235
void *element = NULL;
6237
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
6238
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_FAILURE);
6244
if(_instanceType->property_serviceTag != NULL)
6248
AXIS2_FREE(env-> allocator, _instanceType->property_serviceTag);
6249
_instanceType->property_serviceTag = NULL;
6254
_instanceType->is_valid_serviceTag = AXIS2_FALSE;
6255
return AXIS2_SUCCESS;
6259
* Check whether serviceTag is nill
6261
axis2_bool_t AXIS2_CALL
6262
adb_instanceType_is_serviceTag_nil(
6263
adb_instanceType_t* _instanceType,
6264
const axutil_env_t *env)
6266
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
6267
AXIS2_PARAM_CHECK(env->error, _instanceType, AXIS2_TRUE);
6269
return !_instanceType->is_valid_serviceTag;
6273
* Set serviceTag to nill (currently the same as reset)
6275
axis2_status_t AXIS2_CALL
6276
adb_instanceType_set_serviceTag_nil(
6277
adb_instanceType_t* _instanceType,
6278
const axutil_env_t *env)
6280
return adb_instanceType_reset_serviceTag(_instanceType, env);
added
removed
cluster/generated/adb_instanceType.c
