4
* adb_ncAttachVolumeType.c
6
* This file was auto-generated from WSDL
7
* by the Apache Axis2/C version: SNAPSHOT Built on : Mar 10, 2008 (08:35:52 GMT+00:00)
10
#include "adb_ncAttachVolumeType.h"
13
* This type was generated from the piece of schema that had
14
* name = ncAttachVolumeType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_ncAttachVolumeType
23
axis2_char_t* property_correlationId;
26
axis2_bool_t is_valid_correlationId;
29
axis2_char_t* property_userId;
32
axis2_bool_t is_valid_userId;
35
axis2_bool_t property_return;
38
axis2_bool_t is_valid_return;
41
axis2_char_t* property_nodeName;
44
axis2_bool_t is_valid_nodeName;
47
int property_statusMessage;
50
axis2_bool_t is_valid_statusMessage;
53
axis2_char_t* property_instanceId;
56
axis2_bool_t is_valid_instanceId;
59
axis2_char_t* property_volumeId;
62
axis2_bool_t is_valid_volumeId;
65
axis2_char_t* property_remoteDev;
68
axis2_bool_t is_valid_remoteDev;
71
axis2_char_t* property_localDev;
74
axis2_bool_t is_valid_localDev;
81
/************************* Private Function prototypes ********************************/
84
axis2_status_t AXIS2_CALL
85
adb_ncAttachVolumeType_set_userId_nil(
86
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
87
const axutil_env_t *env);
90
axis2_status_t AXIS2_CALL
91
adb_ncAttachVolumeType_set_return_nil(
92
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
93
const axutil_env_t *env);
96
axis2_status_t AXIS2_CALL
97
adb_ncAttachVolumeType_set_instanceId_nil(
98
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
99
const axutil_env_t *env);
102
axis2_status_t AXIS2_CALL
103
adb_ncAttachVolumeType_set_volumeId_nil(
104
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
105
const axutil_env_t *env);
108
axis2_status_t AXIS2_CALL
109
adb_ncAttachVolumeType_set_remoteDev_nil(
110
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
111
const axutil_env_t *env);
114
axis2_status_t AXIS2_CALL
115
adb_ncAttachVolumeType_set_localDev_nil(
116
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
117
const axutil_env_t *env);
121
/************************* Function Implmentations ********************************/
122
adb_ncAttachVolumeType_t* AXIS2_CALL
123
adb_ncAttachVolumeType_create(
124
const axutil_env_t *env)
126
adb_ncAttachVolumeType_t *_ncAttachVolumeType = NULL;
128
AXIS2_ENV_CHECK(env, NULL);
130
_ncAttachVolumeType = (adb_ncAttachVolumeType_t *) AXIS2_MALLOC(env->
131
allocator, sizeof(adb_ncAttachVolumeType_t));
133
if(NULL == _ncAttachVolumeType)
135
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
139
memset(_ncAttachVolumeType, 0, sizeof(adb_ncAttachVolumeType_t));
141
_ncAttachVolumeType->property_correlationId = NULL;
142
_ncAttachVolumeType->is_valid_correlationId = AXIS2_FALSE;
143
_ncAttachVolumeType->property_userId = NULL;
144
_ncAttachVolumeType->is_valid_userId = AXIS2_FALSE;
145
_ncAttachVolumeType->is_valid_return = AXIS2_FALSE;
146
_ncAttachVolumeType->property_nodeName = NULL;
147
_ncAttachVolumeType->is_valid_nodeName = AXIS2_FALSE;
148
_ncAttachVolumeType->is_valid_statusMessage = AXIS2_FALSE;
149
_ncAttachVolumeType->property_instanceId = NULL;
150
_ncAttachVolumeType->is_valid_instanceId = AXIS2_FALSE;
151
_ncAttachVolumeType->property_volumeId = NULL;
152
_ncAttachVolumeType->is_valid_volumeId = AXIS2_FALSE;
153
_ncAttachVolumeType->property_remoteDev = NULL;
154
_ncAttachVolumeType->is_valid_remoteDev = AXIS2_FALSE;
155
_ncAttachVolumeType->property_localDev = NULL;
156
_ncAttachVolumeType->is_valid_localDev = AXIS2_FALSE;
159
return _ncAttachVolumeType;
162
axis2_status_t AXIS2_CALL
163
adb_ncAttachVolumeType_free (
164
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
165
const axutil_env_t *env)
169
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
170
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
172
adb_ncAttachVolumeType_reset_correlationId(_ncAttachVolumeType, env);
173
adb_ncAttachVolumeType_reset_userId(_ncAttachVolumeType, env);
174
adb_ncAttachVolumeType_reset_return(_ncAttachVolumeType, env);
175
adb_ncAttachVolumeType_reset_nodeName(_ncAttachVolumeType, env);
176
adb_ncAttachVolumeType_reset_statusMessage(_ncAttachVolumeType, env);
177
adb_ncAttachVolumeType_reset_instanceId(_ncAttachVolumeType, env);
178
adb_ncAttachVolumeType_reset_volumeId(_ncAttachVolumeType, env);
179
adb_ncAttachVolumeType_reset_remoteDev(_ncAttachVolumeType, env);
180
adb_ncAttachVolumeType_reset_localDev(_ncAttachVolumeType, env);
183
if(_ncAttachVolumeType)
185
AXIS2_FREE(env->allocator, _ncAttachVolumeType);
186
_ncAttachVolumeType = NULL;
188
return AXIS2_SUCCESS;
194
axis2_status_t AXIS2_CALL
195
adb_ncAttachVolumeType_deserialize(
196
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
197
const axutil_env_t *env,
198
axiom_node_t **dp_parent,
199
axis2_bool_t *dp_is_early_node_valid,
200
axis2_bool_t dont_care_minoccurs)
202
axiom_node_t *parent = *dp_parent;
204
axis2_status_t status = AXIS2_SUCCESS;
206
axis2_char_t* text_value = NULL;
207
axutil_qname_t *qname = NULL;
209
axutil_qname_t *element_qname = NULL;
211
axiom_node_t *first_node = NULL;
212
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
213
axiom_node_t *current_node = NULL;
214
axiom_element_t *current_element = NULL;
216
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
217
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
221
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
223
parent = axiom_node_get_next_sibling(parent, env);
227
/* This should be checked before everything */
228
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
229
"Failed in building adb object for ncAttachVolumeType : "
230
"NULL elemenet can not be passed to deserialize");
231
return AXIS2_FAILURE;
235
first_node = axiom_node_get_first_child(parent, env);
241
* building correlationId element
246
current_node = first_node;
247
is_early_node_valid = AXIS2_FALSE;
250
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
252
current_node = axiom_node_get_next_sibling(current_node, env);
254
if(current_node != NULL)
256
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
257
qname = axiom_element_get_qname(current_element, env, current_node);
260
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
264
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
266
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
268
is_early_node_valid = AXIS2_TRUE;
272
text_value = axiom_element_get_text(current_element, env, current_node);
273
if(text_value != NULL)
275
status = adb_ncAttachVolumeType_set_correlationId(_ncAttachVolumeType, env,
279
if(AXIS2_FAILURE == status)
281
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
284
axutil_qname_free(element_qname, env);
286
return AXIS2_FAILURE;
292
axutil_qname_free(element_qname, env);
293
element_qname = NULL;
299
* building userId element
305
* because elements are ordered this works fine
309
if(current_node != NULL && is_early_node_valid)
311
current_node = axiom_node_get_next_sibling(current_node, env);
314
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
316
current_node = axiom_node_get_next_sibling(current_node, env);
318
if(current_node != NULL)
320
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
321
qname = axiom_element_get_qname(current_element, env, current_node);
325
is_early_node_valid = AXIS2_FALSE;
327
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
331
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
333
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
335
is_early_node_valid = AXIS2_TRUE;
339
text_value = axiom_element_get_text(current_element, env, current_node);
340
if(text_value != NULL)
342
status = adb_ncAttachVolumeType_set_userId(_ncAttachVolumeType, env,
349
* axis2_qname_t *qname = NULL;
350
* axiom_attribute_t *the_attri = NULL;
352
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
353
* the_attri = axiom_element_get_attribute(current_element, env, qname);
355
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
357
axiom_attribute_t *the_attri = NULL;
358
axis2_char_t *attrib_text = NULL;
359
axutil_hash_t *attribute_hash = NULL;
361
attribute_hash = axiom_element_get_all_attributes(current_element, env);
366
axutil_hash_index_t *hi;
370
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
372
axutil_hash_this(hi, &key, NULL, &val);
374
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
376
the_attri = (axiom_attribute_t*)val;
384
attrib_text = axiom_attribute_get_value(the_attri, env);
388
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
389
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
392
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
394
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
395
status = AXIS2_FAILURE;
399
/* after all, we found this is a empty string */
400
status = adb_ncAttachVolumeType_set_userId(_ncAttachVolumeType, env,
405
if(AXIS2_FAILURE == status)
407
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
410
axutil_qname_free(element_qname, env);
412
return AXIS2_FAILURE;
418
axutil_qname_free(element_qname, env);
419
element_qname = NULL;
425
* building return element
431
* because elements are ordered this works fine
435
if(current_node != NULL && is_early_node_valid)
437
current_node = axiom_node_get_next_sibling(current_node, env);
440
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
442
current_node = axiom_node_get_next_sibling(current_node, env);
444
if(current_node != NULL)
446
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
447
qname = axiom_element_get_qname(current_element, env, current_node);
451
is_early_node_valid = AXIS2_FALSE;
453
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
457
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
459
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
461
is_early_node_valid = AXIS2_TRUE;
465
text_value = axiom_element_get_text(current_element, env, current_node);
466
if(text_value != NULL)
468
if (!axutil_strcasecmp(text_value , "true"))
470
status = adb_ncAttachVolumeType_set_return(_ncAttachVolumeType, env,
475
status = adb_ncAttachVolumeType_set_return(_ncAttachVolumeType, env,
482
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
483
status = AXIS2_FAILURE;
486
if(AXIS2_FAILURE == status)
488
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
491
axutil_qname_free(element_qname, env);
493
return AXIS2_FAILURE;
499
axutil_qname_free(element_qname, env);
500
element_qname = NULL;
506
* building nodeName element
512
* because elements are ordered this works fine
516
if(current_node != NULL && is_early_node_valid)
518
current_node = axiom_node_get_next_sibling(current_node, env);
521
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
523
current_node = axiom_node_get_next_sibling(current_node, env);
525
if(current_node != NULL)
527
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
528
qname = axiom_element_get_qname(current_element, env, current_node);
532
is_early_node_valid = AXIS2_FALSE;
534
element_qname = axutil_qname_create(env, "nodeName", "http://eucalyptus.ucsb.edu/", NULL);
538
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
540
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
542
is_early_node_valid = AXIS2_TRUE;
546
text_value = axiom_element_get_text(current_element, env, current_node);
547
if(text_value != NULL)
549
status = adb_ncAttachVolumeType_set_nodeName(_ncAttachVolumeType, env,
553
if(AXIS2_FAILURE == status)
555
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeName ");
558
axutil_qname_free(element_qname, env);
560
return AXIS2_FAILURE;
566
axutil_qname_free(element_qname, env);
567
element_qname = NULL;
573
* building statusMessage element
579
* because elements are ordered this works fine
583
if(current_node != NULL && is_early_node_valid)
585
current_node = axiom_node_get_next_sibling(current_node, env);
588
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
590
current_node = axiom_node_get_next_sibling(current_node, env);
592
if(current_node != NULL)
594
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
595
qname = axiom_element_get_qname(current_element, env, current_node);
599
is_early_node_valid = AXIS2_FALSE;
601
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
605
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
607
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
609
is_early_node_valid = AXIS2_TRUE;
613
text_value = axiom_element_get_text(current_element, env, current_node);
614
if(text_value != NULL)
616
status = adb_ncAttachVolumeType_set_statusMessage(_ncAttachVolumeType, env,
620
if(AXIS2_FAILURE == status)
622
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
625
axutil_qname_free(element_qname, env);
627
return AXIS2_FAILURE;
633
axutil_qname_free(element_qname, env);
634
element_qname = NULL;
640
* building instanceId element
646
* because elements are ordered this works fine
650
if(current_node != NULL && is_early_node_valid)
652
current_node = axiom_node_get_next_sibling(current_node, env);
655
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
657
current_node = axiom_node_get_next_sibling(current_node, env);
659
if(current_node != NULL)
661
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
662
qname = axiom_element_get_qname(current_element, env, current_node);
666
is_early_node_valid = AXIS2_FALSE;
668
element_qname = axutil_qname_create(env, "instanceId", "http://eucalyptus.ucsb.edu/", NULL);
672
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
674
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
676
is_early_node_valid = AXIS2_TRUE;
680
text_value = axiom_element_get_text(current_element, env, current_node);
681
if(text_value != NULL)
683
status = adb_ncAttachVolumeType_set_instanceId(_ncAttachVolumeType, env,
690
* axis2_qname_t *qname = NULL;
691
* axiom_attribute_t *the_attri = NULL;
693
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
694
* the_attri = axiom_element_get_attribute(current_element, env, qname);
696
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
698
axiom_attribute_t *the_attri = NULL;
699
axis2_char_t *attrib_text = NULL;
700
axutil_hash_t *attribute_hash = NULL;
702
attribute_hash = axiom_element_get_all_attributes(current_element, env);
707
axutil_hash_index_t *hi;
711
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
713
axutil_hash_this(hi, &key, NULL, &val);
715
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
717
the_attri = (axiom_attribute_t*)val;
725
attrib_text = axiom_attribute_get_value(the_attri, env);
729
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
730
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
733
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
735
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceId");
736
status = AXIS2_FAILURE;
740
/* after all, we found this is a empty string */
741
status = adb_ncAttachVolumeType_set_instanceId(_ncAttachVolumeType, env,
746
if(AXIS2_FAILURE == status)
748
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceId ");
751
axutil_qname_free(element_qname, env);
753
return AXIS2_FAILURE;
759
axutil_qname_free(element_qname, env);
760
element_qname = NULL;
766
* building volumeId element
772
* because elements are ordered this works fine
776
if(current_node != NULL && is_early_node_valid)
778
current_node = axiom_node_get_next_sibling(current_node, env);
781
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
783
current_node = axiom_node_get_next_sibling(current_node, env);
785
if(current_node != NULL)
787
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
788
qname = axiom_element_get_qname(current_element, env, current_node);
792
is_early_node_valid = AXIS2_FALSE;
794
element_qname = axutil_qname_create(env, "volumeId", "http://eucalyptus.ucsb.edu/", NULL);
798
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
800
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
802
is_early_node_valid = AXIS2_TRUE;
806
text_value = axiom_element_get_text(current_element, env, current_node);
807
if(text_value != NULL)
809
status = adb_ncAttachVolumeType_set_volumeId(_ncAttachVolumeType, env,
816
* axis2_qname_t *qname = NULL;
817
* axiom_attribute_t *the_attri = NULL;
819
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
820
* the_attri = axiom_element_get_attribute(current_element, env, qname);
822
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
824
axiom_attribute_t *the_attri = NULL;
825
axis2_char_t *attrib_text = NULL;
826
axutil_hash_t *attribute_hash = NULL;
828
attribute_hash = axiom_element_get_all_attributes(current_element, env);
833
axutil_hash_index_t *hi;
837
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
839
axutil_hash_this(hi, &key, NULL, &val);
841
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
843
the_attri = (axiom_attribute_t*)val;
851
attrib_text = axiom_attribute_get_value(the_attri, env);
855
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
856
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
859
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
861
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element volumeId");
862
status = AXIS2_FAILURE;
866
/* after all, we found this is a empty string */
867
status = adb_ncAttachVolumeType_set_volumeId(_ncAttachVolumeType, env,
872
if(AXIS2_FAILURE == status)
874
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for volumeId ");
877
axutil_qname_free(element_qname, env);
879
return AXIS2_FAILURE;
885
axutil_qname_free(element_qname, env);
886
element_qname = NULL;
892
* building remoteDev element
898
* because elements are ordered this works fine
902
if(current_node != NULL && is_early_node_valid)
904
current_node = axiom_node_get_next_sibling(current_node, env);
907
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
909
current_node = axiom_node_get_next_sibling(current_node, env);
911
if(current_node != NULL)
913
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
914
qname = axiom_element_get_qname(current_element, env, current_node);
918
is_early_node_valid = AXIS2_FALSE;
920
element_qname = axutil_qname_create(env, "remoteDev", "http://eucalyptus.ucsb.edu/", NULL);
924
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
926
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
928
is_early_node_valid = AXIS2_TRUE;
932
text_value = axiom_element_get_text(current_element, env, current_node);
933
if(text_value != NULL)
935
status = adb_ncAttachVolumeType_set_remoteDev(_ncAttachVolumeType, env,
942
* axis2_qname_t *qname = NULL;
943
* axiom_attribute_t *the_attri = NULL;
945
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
946
* the_attri = axiom_element_get_attribute(current_element, env, qname);
948
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
950
axiom_attribute_t *the_attri = NULL;
951
axis2_char_t *attrib_text = NULL;
952
axutil_hash_t *attribute_hash = NULL;
954
attribute_hash = axiom_element_get_all_attributes(current_element, env);
959
axutil_hash_index_t *hi;
963
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
965
axutil_hash_this(hi, &key, NULL, &val);
967
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
969
the_attri = (axiom_attribute_t*)val;
977
attrib_text = axiom_attribute_get_value(the_attri, env);
981
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
982
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
985
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
987
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element remoteDev");
988
status = AXIS2_FAILURE;
992
/* after all, we found this is a empty string */
993
status = adb_ncAttachVolumeType_set_remoteDev(_ncAttachVolumeType, env,
998
if(AXIS2_FAILURE == status)
1000
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for remoteDev ");
1003
axutil_qname_free(element_qname, env);
1005
return AXIS2_FAILURE;
1011
axutil_qname_free(element_qname, env);
1012
element_qname = NULL;
1018
* building localDev element
1024
* because elements are ordered this works fine
1028
if(current_node != NULL && is_early_node_valid)
1030
current_node = axiom_node_get_next_sibling(current_node, env);
1033
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1035
current_node = axiom_node_get_next_sibling(current_node, env);
1037
if(current_node != NULL)
1039
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1040
qname = axiom_element_get_qname(current_element, env, current_node);
1044
is_early_node_valid = AXIS2_FALSE;
1046
element_qname = axutil_qname_create(env, "localDev", "http://eucalyptus.ucsb.edu/", NULL);
1050
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1052
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1054
is_early_node_valid = AXIS2_TRUE;
1058
text_value = axiom_element_get_text(current_element, env, current_node);
1059
if(text_value != NULL)
1061
status = adb_ncAttachVolumeType_set_localDev(_ncAttachVolumeType, env,
1068
* axis2_qname_t *qname = NULL;
1069
* axiom_attribute_t *the_attri = NULL;
1071
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1072
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1074
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1076
axiom_attribute_t *the_attri = NULL;
1077
axis2_char_t *attrib_text = NULL;
1078
axutil_hash_t *attribute_hash = NULL;
1080
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1085
axutil_hash_index_t *hi;
1089
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1091
axutil_hash_this(hi, &key, NULL, &val);
1093
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1095
the_attri = (axiom_attribute_t*)val;
1103
attrib_text = axiom_attribute_get_value(the_attri, env);
1107
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1108
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1111
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1113
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element localDev");
1114
status = AXIS2_FAILURE;
1118
/* after all, we found this is a empty string */
1119
status = adb_ncAttachVolumeType_set_localDev(_ncAttachVolumeType, env,
1124
if(AXIS2_FAILURE == status)
1126
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for localDev ");
1129
axutil_qname_free(element_qname, env);
1131
return AXIS2_FAILURE;
1137
axutil_qname_free(element_qname, env);
1138
element_qname = NULL;
1144
axis2_bool_t AXIS2_CALL
1145
adb_ncAttachVolumeType_is_particle()
1154
adb_ncAttachVolumeType_declare_parent_namespaces(
1155
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
1156
const axutil_env_t *env, axiom_element_t *parent_element,
1157
axutil_hash_t *namespaces, int *next_ns_index)
1160
/* Here this is an empty function, Nothing to declare */
1166
axiom_node_t* AXIS2_CALL
1167
adb_ncAttachVolumeType_serialize(
1168
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
1169
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)
1173
axis2_char_t *string_to_stream;
1176
axiom_node_t *current_node = NULL;
1181
axiom_namespace_t *ns1 = NULL;
1183
axis2_char_t *qname_uri = NULL;
1184
axis2_char_t *qname_prefix = NULL;
1185
axis2_char_t *p_prefix = NULL;
1186
axis2_bool_t ns_already_defined;
1188
axis2_char_t *text_value_1;
1189
axis2_char_t *text_value_1_temp;
1191
axis2_char_t *text_value_2;
1192
axis2_char_t *text_value_2_temp;
1194
axis2_char_t text_value_3[64];
1196
axis2_char_t *text_value_4;
1197
axis2_char_t *text_value_4_temp;
1199
axis2_char_t text_value_5[64];
1201
axis2_char_t *text_value_6;
1202
axis2_char_t *text_value_6_temp;
1204
axis2_char_t *text_value_7;
1205
axis2_char_t *text_value_7_temp;
1207
axis2_char_t *text_value_8;
1208
axis2_char_t *text_value_8_temp;
1210
axis2_char_t *text_value_9;
1211
axis2_char_t *text_value_9_temp;
1213
axis2_char_t *start_input_str = NULL;
1214
axis2_char_t *end_input_str = NULL;
1215
unsigned int start_input_str_len = 0;
1216
unsigned int end_input_str_len = 0;
1219
axiom_data_source_t *data_source = NULL;
1220
axutil_stream_t *stream = NULL;
1224
AXIS2_ENV_CHECK(env, NULL);
1225
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
1228
current_node = parent;
1229
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1232
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1236
if(!parent_tag_closed)
1239
string_to_stream = ">";
1240
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1245
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1247
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1248
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1249
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1251
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1252
"http://eucalyptus.ucsb.edu/",
1257
if (!_ncAttachVolumeType->is_valid_correlationId)
1260
/* no need to complain for minoccurs=0 element */
1266
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1267
(4 + axutil_strlen(p_prefix) +
1268
axutil_strlen("correlationId")));
1270
/* axutil_strlen("<:>") + 1 = 4 */
1271
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1272
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1273
/* axutil_strlen("</:>") + 1 = 5 */
1281
* parsing correlationId element
1286
sprintf(start_input_str, "<%s%scorrelationId>",
1287
p_prefix?p_prefix:"",
1288
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1290
start_input_str_len = axutil_strlen(start_input_str);
1291
sprintf(end_input_str, "</%s%scorrelationId>",
1292
p_prefix?p_prefix:"",
1293
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1294
end_input_str_len = axutil_strlen(end_input_str);
1296
text_value_1 = _ncAttachVolumeType->property_correlationId;
1298
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1301
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1302
if (text_value_1_temp)
1304
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1305
AXIS2_FREE(env->allocator, text_value_1_temp);
1309
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1312
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1315
AXIS2_FREE(env->allocator,start_input_str);
1316
AXIS2_FREE(env->allocator,end_input_str);
1320
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1322
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1323
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1324
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1326
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1327
"http://eucalyptus.ucsb.edu/",
1332
if (!_ncAttachVolumeType->is_valid_userId)
1335
/* no need to complain for minoccurs=0 element */
1341
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1342
(4 + axutil_strlen(p_prefix) +
1343
axutil_strlen("userId")));
1345
/* axutil_strlen("<:>") + 1 = 4 */
1346
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1347
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1348
/* axutil_strlen("</:>") + 1 = 5 */
1356
* parsing userId element
1361
sprintf(start_input_str, "<%s%suserId>",
1362
p_prefix?p_prefix:"",
1363
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1365
start_input_str_len = axutil_strlen(start_input_str);
1366
sprintf(end_input_str, "</%s%suserId>",
1367
p_prefix?p_prefix:"",
1368
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1369
end_input_str_len = axutil_strlen(end_input_str);
1371
text_value_2 = _ncAttachVolumeType->property_userId;
1373
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1376
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1377
if (text_value_2_temp)
1379
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1380
AXIS2_FREE(env->allocator, text_value_2_temp);
1384
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1387
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1390
AXIS2_FREE(env->allocator,start_input_str);
1391
AXIS2_FREE(env->allocator,end_input_str);
1395
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1397
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1398
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1399
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1401
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1402
"http://eucalyptus.ucsb.edu/",
1407
if (!_ncAttachVolumeType->is_valid_return)
1410
/* no need to complain for minoccurs=0 element */
1416
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1417
(4 + axutil_strlen(p_prefix) +
1418
axutil_strlen("return")));
1420
/* axutil_strlen("<:>") + 1 = 4 */
1421
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1422
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1423
/* axutil_strlen("</:>") + 1 = 5 */
1431
* parsing return element
1436
sprintf(start_input_str, "<%s%sreturn>",
1437
p_prefix?p_prefix:"",
1438
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1440
start_input_str_len = axutil_strlen(start_input_str);
1441
sprintf(end_input_str, "</%s%sreturn>",
1442
p_prefix?p_prefix:"",
1443
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1444
end_input_str_len = axutil_strlen(end_input_str);
1446
strcpy(text_value_3, (_ncAttachVolumeType->property_return)?"true":"false");
1448
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1450
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1452
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1455
AXIS2_FREE(env->allocator,start_input_str);
1456
AXIS2_FREE(env->allocator,end_input_str);
1460
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1462
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1463
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1464
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1466
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1467
"http://eucalyptus.ucsb.edu/",
1472
if (!_ncAttachVolumeType->is_valid_nodeName)
1475
/* no need to complain for minoccurs=0 element */
1481
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1482
(4 + axutil_strlen(p_prefix) +
1483
axutil_strlen("nodeName")));
1485
/* axutil_strlen("<:>") + 1 = 4 */
1486
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1487
(5 + axutil_strlen(p_prefix) + axutil_strlen("nodeName")));
1488
/* axutil_strlen("</:>") + 1 = 5 */
1496
* parsing nodeName element
1501
sprintf(start_input_str, "<%s%snodeName>",
1502
p_prefix?p_prefix:"",
1503
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1505
start_input_str_len = axutil_strlen(start_input_str);
1506
sprintf(end_input_str, "</%s%snodeName>",
1507
p_prefix?p_prefix:"",
1508
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1509
end_input_str_len = axutil_strlen(end_input_str);
1511
text_value_4 = _ncAttachVolumeType->property_nodeName;
1513
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1516
text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
1517
if (text_value_4_temp)
1519
axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
1520
AXIS2_FREE(env->allocator, text_value_4_temp);
1524
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1527
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1530
AXIS2_FREE(env->allocator,start_input_str);
1531
AXIS2_FREE(env->allocator,end_input_str);
1535
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1537
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1538
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1539
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1541
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1542
"http://eucalyptus.ucsb.edu/",
1547
if (!_ncAttachVolumeType->is_valid_statusMessage)
1550
/* no need to complain for minoccurs=0 element */
1556
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1557
(4 + axutil_strlen(p_prefix) +
1558
axutil_strlen("statusMessage")));
1560
/* axutil_strlen("<:>") + 1 = 4 */
1561
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1562
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1563
/* axutil_strlen("</:>") + 1 = 5 */
1571
* parsing statusMessage element
1576
sprintf(start_input_str, "<%s%sstatusMessage>",
1577
p_prefix?p_prefix:"",
1578
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1580
start_input_str_len = axutil_strlen(start_input_str);
1581
sprintf(end_input_str, "</%s%sstatusMessage>",
1582
p_prefix?p_prefix:"",
1583
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1584
end_input_str_len = axutil_strlen(end_input_str);
1586
sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncAttachVolumeType->property_statusMessage);
1588
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1590
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1592
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1595
AXIS2_FREE(env->allocator,start_input_str);
1596
AXIS2_FREE(env->allocator,end_input_str);
1600
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1602
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1603
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1604
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1606
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1607
"http://eucalyptus.ucsb.edu/",
1612
if (!_ncAttachVolumeType->is_valid_instanceId)
1615
/* no need to complain for minoccurs=0 element */
1621
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1622
(4 + axutil_strlen(p_prefix) +
1623
axutil_strlen("instanceId")));
1625
/* axutil_strlen("<:>") + 1 = 4 */
1626
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1627
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceId")));
1628
/* axutil_strlen("</:>") + 1 = 5 */
1636
* parsing instanceId element
1641
sprintf(start_input_str, "<%s%sinstanceId>",
1642
p_prefix?p_prefix:"",
1643
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1645
start_input_str_len = axutil_strlen(start_input_str);
1646
sprintf(end_input_str, "</%s%sinstanceId>",
1647
p_prefix?p_prefix:"",
1648
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1649
end_input_str_len = axutil_strlen(end_input_str);
1651
text_value_6 = _ncAttachVolumeType->property_instanceId;
1653
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1656
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1657
if (text_value_6_temp)
1659
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1660
AXIS2_FREE(env->allocator, text_value_6_temp);
1664
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1667
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1670
AXIS2_FREE(env->allocator,start_input_str);
1671
AXIS2_FREE(env->allocator,end_input_str);
1675
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1677
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1678
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1679
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1681
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1682
"http://eucalyptus.ucsb.edu/",
1687
if (!_ncAttachVolumeType->is_valid_volumeId)
1690
/* no need to complain for minoccurs=0 element */
1696
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1697
(4 + axutil_strlen(p_prefix) +
1698
axutil_strlen("volumeId")));
1700
/* axutil_strlen("<:>") + 1 = 4 */
1701
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1702
(5 + axutil_strlen(p_prefix) + axutil_strlen("volumeId")));
1703
/* axutil_strlen("</:>") + 1 = 5 */
1711
* parsing volumeId element
1716
sprintf(start_input_str, "<%s%svolumeId>",
1717
p_prefix?p_prefix:"",
1718
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1720
start_input_str_len = axutil_strlen(start_input_str);
1721
sprintf(end_input_str, "</%s%svolumeId>",
1722
p_prefix?p_prefix:"",
1723
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1724
end_input_str_len = axutil_strlen(end_input_str);
1726
text_value_7 = _ncAttachVolumeType->property_volumeId;
1728
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1731
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1732
if (text_value_7_temp)
1734
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
1735
AXIS2_FREE(env->allocator, text_value_7_temp);
1739
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1742
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1745
AXIS2_FREE(env->allocator,start_input_str);
1746
AXIS2_FREE(env->allocator,end_input_str);
1750
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1752
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1753
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1754
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1756
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1757
"http://eucalyptus.ucsb.edu/",
1762
if (!_ncAttachVolumeType->is_valid_remoteDev)
1765
/* no need to complain for minoccurs=0 element */
1771
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1772
(4 + axutil_strlen(p_prefix) +
1773
axutil_strlen("remoteDev")));
1775
/* axutil_strlen("<:>") + 1 = 4 */
1776
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1777
(5 + axutil_strlen(p_prefix) + axutil_strlen("remoteDev")));
1778
/* axutil_strlen("</:>") + 1 = 5 */
1786
* parsing remoteDev element
1791
sprintf(start_input_str, "<%s%sremoteDev>",
1792
p_prefix?p_prefix:"",
1793
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1795
start_input_str_len = axutil_strlen(start_input_str);
1796
sprintf(end_input_str, "</%s%sremoteDev>",
1797
p_prefix?p_prefix:"",
1798
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1799
end_input_str_len = axutil_strlen(end_input_str);
1801
text_value_8 = _ncAttachVolumeType->property_remoteDev;
1803
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1806
text_value_8_temp = axutil_xml_quote_string(env, text_value_8, AXIS2_TRUE);
1807
if (text_value_8_temp)
1809
axutil_stream_write(stream, env, text_value_8_temp, axutil_strlen(text_value_8_temp));
1810
AXIS2_FREE(env->allocator, text_value_8_temp);
1814
axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
1817
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1820
AXIS2_FREE(env->allocator,start_input_str);
1821
AXIS2_FREE(env->allocator,end_input_str);
1825
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1827
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1828
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1829
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1831
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1832
"http://eucalyptus.ucsb.edu/",
1837
if (!_ncAttachVolumeType->is_valid_localDev)
1840
/* no need to complain for minoccurs=0 element */
1846
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1847
(4 + axutil_strlen(p_prefix) +
1848
axutil_strlen("localDev")));
1850
/* axutil_strlen("<:>") + 1 = 4 */
1851
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1852
(5 + axutil_strlen(p_prefix) + axutil_strlen("localDev")));
1853
/* axutil_strlen("</:>") + 1 = 5 */
1861
* parsing localDev element
1866
sprintf(start_input_str, "<%s%slocalDev>",
1867
p_prefix?p_prefix:"",
1868
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1870
start_input_str_len = axutil_strlen(start_input_str);
1871
sprintf(end_input_str, "</%s%slocalDev>",
1872
p_prefix?p_prefix:"",
1873
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1874
end_input_str_len = axutil_strlen(end_input_str);
1876
text_value_9 = _ncAttachVolumeType->property_localDev;
1878
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1881
text_value_9_temp = axutil_xml_quote_string(env, text_value_9, AXIS2_TRUE);
1882
if (text_value_9_temp)
1884
axutil_stream_write(stream, env, text_value_9_temp, axutil_strlen(text_value_9_temp));
1885
AXIS2_FREE(env->allocator, text_value_9_temp);
1889
axutil_stream_write(stream, env, text_value_9, axutil_strlen(text_value_9));
1892
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1895
AXIS2_FREE(env->allocator,start_input_str);
1896
AXIS2_FREE(env->allocator,end_input_str);
1908
* getter for correlationId.
1910
axis2_char_t* AXIS2_CALL
1911
adb_ncAttachVolumeType_get_correlationId(
1912
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
1913
const axutil_env_t *env)
1916
AXIS2_ENV_CHECK(env, NULL);
1917
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
1920
return _ncAttachVolumeType->property_correlationId;
1924
* setter for correlationId
1926
axis2_status_t AXIS2_CALL
1927
adb_ncAttachVolumeType_set_correlationId(
1928
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
1929
const axutil_env_t *env,
1930
const axis2_char_t* arg_correlationId)
1934
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1935
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
1937
if(_ncAttachVolumeType->is_valid_correlationId &&
1938
arg_correlationId == _ncAttachVolumeType->property_correlationId)
1941
return AXIS2_SUCCESS;
1944
adb_ncAttachVolumeType_reset_correlationId(_ncAttachVolumeType, env);
1947
if(NULL == arg_correlationId)
1949
/* We are already done */
1950
return AXIS2_SUCCESS;
1952
_ncAttachVolumeType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1953
if(NULL == _ncAttachVolumeType->property_correlationId)
1955
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1956
return AXIS2_FAILURE;
1958
_ncAttachVolumeType->is_valid_correlationId = AXIS2_TRUE;
1960
return AXIS2_SUCCESS;
1966
* resetter for correlationId
1968
axis2_status_t AXIS2_CALL
1969
adb_ncAttachVolumeType_reset_correlationId(
1970
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
1971
const axutil_env_t *env)
1975
void *element = NULL;
1977
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1978
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
1984
if(_ncAttachVolumeType->property_correlationId != NULL)
1988
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_correlationId);
1989
_ncAttachVolumeType->property_correlationId = NULL;
1994
_ncAttachVolumeType->is_valid_correlationId = AXIS2_FALSE;
1995
return AXIS2_SUCCESS;
1999
* Check whether correlationId is nill
2001
axis2_bool_t AXIS2_CALL
2002
adb_ncAttachVolumeType_is_correlationId_nil(
2003
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2004
const axutil_env_t *env)
2006
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2007
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2009
return !_ncAttachVolumeType->is_valid_correlationId;
2013
* Set correlationId to nill (currently the same as reset)
2015
axis2_status_t AXIS2_CALL
2016
adb_ncAttachVolumeType_set_correlationId_nil(
2017
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2018
const axutil_env_t *env)
2020
return adb_ncAttachVolumeType_reset_correlationId(_ncAttachVolumeType, env);
2026
* getter for userId.
2028
axis2_char_t* AXIS2_CALL
2029
adb_ncAttachVolumeType_get_userId(
2030
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2031
const axutil_env_t *env)
2034
AXIS2_ENV_CHECK(env, NULL);
2035
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2038
return _ncAttachVolumeType->property_userId;
2044
axis2_status_t AXIS2_CALL
2045
adb_ncAttachVolumeType_set_userId(
2046
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2047
const axutil_env_t *env,
2048
const axis2_char_t* arg_userId)
2052
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2053
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2055
if(_ncAttachVolumeType->is_valid_userId &&
2056
arg_userId == _ncAttachVolumeType->property_userId)
2059
return AXIS2_SUCCESS;
2062
adb_ncAttachVolumeType_reset_userId(_ncAttachVolumeType, env);
2065
if(NULL == arg_userId)
2067
/* We are already done */
2068
return AXIS2_SUCCESS;
2070
_ncAttachVolumeType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
2071
if(NULL == _ncAttachVolumeType->property_userId)
2073
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
2074
return AXIS2_FAILURE;
2076
_ncAttachVolumeType->is_valid_userId = AXIS2_TRUE;
2078
return AXIS2_SUCCESS;
2084
* resetter for userId
2086
axis2_status_t AXIS2_CALL
2087
adb_ncAttachVolumeType_reset_userId(
2088
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2089
const axutil_env_t *env)
2093
void *element = NULL;
2095
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2096
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2102
if(_ncAttachVolumeType->property_userId != NULL)
2106
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_userId);
2107
_ncAttachVolumeType->property_userId = NULL;
2112
_ncAttachVolumeType->is_valid_userId = AXIS2_FALSE;
2113
return AXIS2_SUCCESS;
2117
* Check whether userId is nill
2119
axis2_bool_t AXIS2_CALL
2120
adb_ncAttachVolumeType_is_userId_nil(
2121
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2122
const axutil_env_t *env)
2124
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2125
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2127
return !_ncAttachVolumeType->is_valid_userId;
2131
* Set userId to nill (currently the same as reset)
2133
axis2_status_t AXIS2_CALL
2134
adb_ncAttachVolumeType_set_userId_nil(
2135
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2136
const axutil_env_t *env)
2138
return adb_ncAttachVolumeType_reset_userId(_ncAttachVolumeType, env);
2144
* getter for return.
2146
axis2_bool_t AXIS2_CALL
2147
adb_ncAttachVolumeType_get_return(
2148
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2149
const axutil_env_t *env)
2152
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
2153
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, (axis2_bool_t)0);
2156
return _ncAttachVolumeType->property_return;
2162
axis2_status_t AXIS2_CALL
2163
adb_ncAttachVolumeType_set_return(
2164
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2165
const axutil_env_t *env,
2166
axis2_bool_t arg_return)
2170
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2171
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2173
if(_ncAttachVolumeType->is_valid_return &&
2174
arg_return == _ncAttachVolumeType->property_return)
2177
return AXIS2_SUCCESS;
2180
adb_ncAttachVolumeType_reset_return(_ncAttachVolumeType, env);
2182
_ncAttachVolumeType->property_return = arg_return;
2183
_ncAttachVolumeType->is_valid_return = AXIS2_TRUE;
2185
return AXIS2_SUCCESS;
2191
* resetter for return
2193
axis2_status_t AXIS2_CALL
2194
adb_ncAttachVolumeType_reset_return(
2195
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2196
const axutil_env_t *env)
2200
void *element = NULL;
2202
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2203
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2206
_ncAttachVolumeType->is_valid_return = AXIS2_FALSE;
2207
return AXIS2_SUCCESS;
2211
* Check whether return is nill
2213
axis2_bool_t AXIS2_CALL
2214
adb_ncAttachVolumeType_is_return_nil(
2215
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2216
const axutil_env_t *env)
2218
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2219
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2221
return !_ncAttachVolumeType->is_valid_return;
2225
* Set return to nill (currently the same as reset)
2227
axis2_status_t AXIS2_CALL
2228
adb_ncAttachVolumeType_set_return_nil(
2229
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2230
const axutil_env_t *env)
2232
return adb_ncAttachVolumeType_reset_return(_ncAttachVolumeType, env);
2238
* getter for nodeName.
2240
axis2_char_t* AXIS2_CALL
2241
adb_ncAttachVolumeType_get_nodeName(
2242
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2243
const axutil_env_t *env)
2246
AXIS2_ENV_CHECK(env, NULL);
2247
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2250
return _ncAttachVolumeType->property_nodeName;
2254
* setter for nodeName
2256
axis2_status_t AXIS2_CALL
2257
adb_ncAttachVolumeType_set_nodeName(
2258
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2259
const axutil_env_t *env,
2260
const axis2_char_t* arg_nodeName)
2264
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2265
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2267
if(_ncAttachVolumeType->is_valid_nodeName &&
2268
arg_nodeName == _ncAttachVolumeType->property_nodeName)
2271
return AXIS2_SUCCESS;
2274
adb_ncAttachVolumeType_reset_nodeName(_ncAttachVolumeType, env);
2277
if(NULL == arg_nodeName)
2279
/* We are already done */
2280
return AXIS2_SUCCESS;
2282
_ncAttachVolumeType->property_nodeName = (axis2_char_t *)axutil_strdup(env, arg_nodeName);
2283
if(NULL == _ncAttachVolumeType->property_nodeName)
2285
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeName");
2286
return AXIS2_FAILURE;
2288
_ncAttachVolumeType->is_valid_nodeName = AXIS2_TRUE;
2290
return AXIS2_SUCCESS;
2296
* resetter for nodeName
2298
axis2_status_t AXIS2_CALL
2299
adb_ncAttachVolumeType_reset_nodeName(
2300
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2301
const axutil_env_t *env)
2305
void *element = NULL;
2307
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2308
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2314
if(_ncAttachVolumeType->property_nodeName != NULL)
2318
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_nodeName);
2319
_ncAttachVolumeType->property_nodeName = NULL;
2324
_ncAttachVolumeType->is_valid_nodeName = AXIS2_FALSE;
2325
return AXIS2_SUCCESS;
2329
* Check whether nodeName is nill
2331
axis2_bool_t AXIS2_CALL
2332
adb_ncAttachVolumeType_is_nodeName_nil(
2333
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2334
const axutil_env_t *env)
2336
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2337
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2339
return !_ncAttachVolumeType->is_valid_nodeName;
2343
* Set nodeName to nill (currently the same as reset)
2345
axis2_status_t AXIS2_CALL
2346
adb_ncAttachVolumeType_set_nodeName_nil(
2347
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2348
const axutil_env_t *env)
2350
return adb_ncAttachVolumeType_reset_nodeName(_ncAttachVolumeType, env);
2356
* getter for statusMessage.
2359
adb_ncAttachVolumeType_get_statusMessage(
2360
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2361
const axutil_env_t *env)
2364
AXIS2_ENV_CHECK(env, (int)0);
2365
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, (int)0);
2368
return _ncAttachVolumeType->property_statusMessage;
2372
* setter for statusMessage
2374
axis2_status_t AXIS2_CALL
2375
adb_ncAttachVolumeType_set_statusMessage(
2376
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2377
const axutil_env_t *env,
2378
const int arg_statusMessage)
2382
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2383
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2385
if(_ncAttachVolumeType->is_valid_statusMessage &&
2386
arg_statusMessage == _ncAttachVolumeType->property_statusMessage)
2389
return AXIS2_SUCCESS;
2392
adb_ncAttachVolumeType_reset_statusMessage(_ncAttachVolumeType, env);
2394
_ncAttachVolumeType->property_statusMessage = arg_statusMessage;
2395
_ncAttachVolumeType->is_valid_statusMessage = AXIS2_TRUE;
2397
return AXIS2_SUCCESS;
2403
* resetter for statusMessage
2405
axis2_status_t AXIS2_CALL
2406
adb_ncAttachVolumeType_reset_statusMessage(
2407
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2408
const axutil_env_t *env)
2412
void *element = NULL;
2414
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2415
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2418
_ncAttachVolumeType->is_valid_statusMessage = AXIS2_FALSE;
2419
return AXIS2_SUCCESS;
2423
* Check whether statusMessage is nill
2425
axis2_bool_t AXIS2_CALL
2426
adb_ncAttachVolumeType_is_statusMessage_nil(
2427
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2428
const axutil_env_t *env)
2430
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2431
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2433
return !_ncAttachVolumeType->is_valid_statusMessage;
2437
* Set statusMessage to nill (currently the same as reset)
2439
axis2_status_t AXIS2_CALL
2440
adb_ncAttachVolumeType_set_statusMessage_nil(
2441
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2442
const axutil_env_t *env)
2444
return adb_ncAttachVolumeType_reset_statusMessage(_ncAttachVolumeType, env);
2450
* getter for instanceId.
2452
axis2_char_t* AXIS2_CALL
2453
adb_ncAttachVolumeType_get_instanceId(
2454
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2455
const axutil_env_t *env)
2458
AXIS2_ENV_CHECK(env, NULL);
2459
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2462
return _ncAttachVolumeType->property_instanceId;
2466
* setter for instanceId
2468
axis2_status_t AXIS2_CALL
2469
adb_ncAttachVolumeType_set_instanceId(
2470
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2471
const axutil_env_t *env,
2472
const axis2_char_t* arg_instanceId)
2476
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2477
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2479
if(_ncAttachVolumeType->is_valid_instanceId &&
2480
arg_instanceId == _ncAttachVolumeType->property_instanceId)
2483
return AXIS2_SUCCESS;
2486
adb_ncAttachVolumeType_reset_instanceId(_ncAttachVolumeType, env);
2489
if(NULL == arg_instanceId)
2491
/* We are already done */
2492
return AXIS2_SUCCESS;
2494
_ncAttachVolumeType->property_instanceId = (axis2_char_t *)axutil_strdup(env, arg_instanceId);
2495
if(NULL == _ncAttachVolumeType->property_instanceId)
2497
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for instanceId");
2498
return AXIS2_FAILURE;
2500
_ncAttachVolumeType->is_valid_instanceId = AXIS2_TRUE;
2502
return AXIS2_SUCCESS;
2508
* resetter for instanceId
2510
axis2_status_t AXIS2_CALL
2511
adb_ncAttachVolumeType_reset_instanceId(
2512
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2513
const axutil_env_t *env)
2517
void *element = NULL;
2519
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2520
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2526
if(_ncAttachVolumeType->property_instanceId != NULL)
2530
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_instanceId);
2531
_ncAttachVolumeType->property_instanceId = NULL;
2536
_ncAttachVolumeType->is_valid_instanceId = AXIS2_FALSE;
2537
return AXIS2_SUCCESS;
2541
* Check whether instanceId is nill
2543
axis2_bool_t AXIS2_CALL
2544
adb_ncAttachVolumeType_is_instanceId_nil(
2545
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2546
const axutil_env_t *env)
2548
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2549
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2551
return !_ncAttachVolumeType->is_valid_instanceId;
2555
* Set instanceId to nill (currently the same as reset)
2557
axis2_status_t AXIS2_CALL
2558
adb_ncAttachVolumeType_set_instanceId_nil(
2559
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2560
const axutil_env_t *env)
2562
return adb_ncAttachVolumeType_reset_instanceId(_ncAttachVolumeType, env);
2568
* getter for volumeId.
2570
axis2_char_t* AXIS2_CALL
2571
adb_ncAttachVolumeType_get_volumeId(
2572
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2573
const axutil_env_t *env)
2576
AXIS2_ENV_CHECK(env, NULL);
2577
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2580
return _ncAttachVolumeType->property_volumeId;
2584
* setter for volumeId
2586
axis2_status_t AXIS2_CALL
2587
adb_ncAttachVolumeType_set_volumeId(
2588
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2589
const axutil_env_t *env,
2590
const axis2_char_t* arg_volumeId)
2594
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2595
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2597
if(_ncAttachVolumeType->is_valid_volumeId &&
2598
arg_volumeId == _ncAttachVolumeType->property_volumeId)
2601
return AXIS2_SUCCESS;
2604
adb_ncAttachVolumeType_reset_volumeId(_ncAttachVolumeType, env);
2607
if(NULL == arg_volumeId)
2609
/* We are already done */
2610
return AXIS2_SUCCESS;
2612
_ncAttachVolumeType->property_volumeId = (axis2_char_t *)axutil_strdup(env, arg_volumeId);
2613
if(NULL == _ncAttachVolumeType->property_volumeId)
2615
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for volumeId");
2616
return AXIS2_FAILURE;
2618
_ncAttachVolumeType->is_valid_volumeId = AXIS2_TRUE;
2620
return AXIS2_SUCCESS;
2626
* resetter for volumeId
2628
axis2_status_t AXIS2_CALL
2629
adb_ncAttachVolumeType_reset_volumeId(
2630
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2631
const axutil_env_t *env)
2635
void *element = NULL;
2637
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2638
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2644
if(_ncAttachVolumeType->property_volumeId != NULL)
2648
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_volumeId);
2649
_ncAttachVolumeType->property_volumeId = NULL;
2654
_ncAttachVolumeType->is_valid_volumeId = AXIS2_FALSE;
2655
return AXIS2_SUCCESS;
2659
* Check whether volumeId is nill
2661
axis2_bool_t AXIS2_CALL
2662
adb_ncAttachVolumeType_is_volumeId_nil(
2663
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2664
const axutil_env_t *env)
2666
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2667
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2669
return !_ncAttachVolumeType->is_valid_volumeId;
2673
* Set volumeId to nill (currently the same as reset)
2675
axis2_status_t AXIS2_CALL
2676
adb_ncAttachVolumeType_set_volumeId_nil(
2677
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2678
const axutil_env_t *env)
2680
return adb_ncAttachVolumeType_reset_volumeId(_ncAttachVolumeType, env);
2686
* getter for remoteDev.
2688
axis2_char_t* AXIS2_CALL
2689
adb_ncAttachVolumeType_get_remoteDev(
2690
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2691
const axutil_env_t *env)
2694
AXIS2_ENV_CHECK(env, NULL);
2695
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2698
return _ncAttachVolumeType->property_remoteDev;
2702
* setter for remoteDev
2704
axis2_status_t AXIS2_CALL
2705
adb_ncAttachVolumeType_set_remoteDev(
2706
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2707
const axutil_env_t *env,
2708
const axis2_char_t* arg_remoteDev)
2712
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2713
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2715
if(_ncAttachVolumeType->is_valid_remoteDev &&
2716
arg_remoteDev == _ncAttachVolumeType->property_remoteDev)
2719
return AXIS2_SUCCESS;
2722
adb_ncAttachVolumeType_reset_remoteDev(_ncAttachVolumeType, env);
2725
if(NULL == arg_remoteDev)
2727
/* We are already done */
2728
return AXIS2_SUCCESS;
2730
_ncAttachVolumeType->property_remoteDev = (axis2_char_t *)axutil_strdup(env, arg_remoteDev);
2731
if(NULL == _ncAttachVolumeType->property_remoteDev)
2733
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for remoteDev");
2734
return AXIS2_FAILURE;
2736
_ncAttachVolumeType->is_valid_remoteDev = AXIS2_TRUE;
2738
return AXIS2_SUCCESS;
2744
* resetter for remoteDev
2746
axis2_status_t AXIS2_CALL
2747
adb_ncAttachVolumeType_reset_remoteDev(
2748
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2749
const axutil_env_t *env)
2753
void *element = NULL;
2755
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2756
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2762
if(_ncAttachVolumeType->property_remoteDev != NULL)
2766
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_remoteDev);
2767
_ncAttachVolumeType->property_remoteDev = NULL;
2772
_ncAttachVolumeType->is_valid_remoteDev = AXIS2_FALSE;
2773
return AXIS2_SUCCESS;
2777
* Check whether remoteDev is nill
2779
axis2_bool_t AXIS2_CALL
2780
adb_ncAttachVolumeType_is_remoteDev_nil(
2781
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2782
const axutil_env_t *env)
2784
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2785
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2787
return !_ncAttachVolumeType->is_valid_remoteDev;
2791
* Set remoteDev to nill (currently the same as reset)
2793
axis2_status_t AXIS2_CALL
2794
adb_ncAttachVolumeType_set_remoteDev_nil(
2795
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2796
const axutil_env_t *env)
2798
return adb_ncAttachVolumeType_reset_remoteDev(_ncAttachVolumeType, env);
2804
* getter for localDev.
2806
axis2_char_t* AXIS2_CALL
2807
adb_ncAttachVolumeType_get_localDev(
2808
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2809
const axutil_env_t *env)
2812
AXIS2_ENV_CHECK(env, NULL);
2813
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2816
return _ncAttachVolumeType->property_localDev;
2820
* setter for localDev
2822
axis2_status_t AXIS2_CALL
2823
adb_ncAttachVolumeType_set_localDev(
2824
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2825
const axutil_env_t *env,
2826
const axis2_char_t* arg_localDev)
2830
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2831
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2833
if(_ncAttachVolumeType->is_valid_localDev &&
2834
arg_localDev == _ncAttachVolumeType->property_localDev)
2837
return AXIS2_SUCCESS;
2840
adb_ncAttachVolumeType_reset_localDev(_ncAttachVolumeType, env);
2843
if(NULL == arg_localDev)
2845
/* We are already done */
2846
return AXIS2_SUCCESS;
2848
_ncAttachVolumeType->property_localDev = (axis2_char_t *)axutil_strdup(env, arg_localDev);
2849
if(NULL == _ncAttachVolumeType->property_localDev)
2851
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for localDev");
2852
return AXIS2_FAILURE;
2854
_ncAttachVolumeType->is_valid_localDev = AXIS2_TRUE;
2856
return AXIS2_SUCCESS;
2862
* resetter for localDev
2864
axis2_status_t AXIS2_CALL
2865
adb_ncAttachVolumeType_reset_localDev(
2866
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2867
const axutil_env_t *env)
2871
void *element = NULL;
2873
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2874
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2880
if(_ncAttachVolumeType->property_localDev != NULL)
2884
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_localDev);
2885
_ncAttachVolumeType->property_localDev = NULL;
2890
_ncAttachVolumeType->is_valid_localDev = AXIS2_FALSE;
2891
return AXIS2_SUCCESS;
2895
* Check whether localDev is nill
2897
axis2_bool_t AXIS2_CALL
2898
adb_ncAttachVolumeType_is_localDev_nil(
2899
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2900
const axutil_env_t *env)
2902
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2903
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2905
return !_ncAttachVolumeType->is_valid_localDev;
2909
* Set localDev to nill (currently the same as reset)
2911
axis2_status_t AXIS2_CALL
2912
adb_ncAttachVolumeType_set_localDev_nil(
2913
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2914
const axutil_env_t *env)
2916
return adb_ncAttachVolumeType_reset_localDev(_ncAttachVolumeType, env);
added
removed
node/generated/adb_ncAttachVolumeType.c
