4
* adb_ncTerminateInstanceResponseType.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_ncTerminateInstanceResponseType.h"
13
* This type was generated from the piece of schema that had
14
* name = ncTerminateInstanceResponseType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_ncTerminateInstanceResponseType
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
int property_statusMessage;
44
axis2_bool_t is_valid_statusMessage;
47
axis2_char_t* property_instanceId;
50
axis2_bool_t is_valid_instanceId;
53
axis2_char_t* property_shutdownState;
56
axis2_bool_t is_valid_shutdownState;
59
axis2_char_t* property_previousState;
62
axis2_bool_t is_valid_previousState;
69
/************************* Private Function prototypes ********************************/
72
axis2_status_t AXIS2_CALL
73
adb_ncTerminateInstanceResponseType_set_correlationId_nil(
74
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_ncTerminateInstanceResponseType_set_userId_nil(
80
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
81
const axutil_env_t *env);
84
axis2_status_t AXIS2_CALL
85
adb_ncTerminateInstanceResponseType_set_return_nil(
86
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
87
const axutil_env_t *env);
90
axis2_status_t AXIS2_CALL
91
adb_ncTerminateInstanceResponseType_set_instanceId_nil(
92
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
93
const axutil_env_t *env);
96
axis2_status_t AXIS2_CALL
97
adb_ncTerminateInstanceResponseType_set_shutdownState_nil(
98
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
99
const axutil_env_t *env);
102
axis2_status_t AXIS2_CALL
103
adb_ncTerminateInstanceResponseType_set_previousState_nil(
104
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
105
const axutil_env_t *env);
109
/************************* Function Implmentations ********************************/
110
adb_ncTerminateInstanceResponseType_t* AXIS2_CALL
111
adb_ncTerminateInstanceResponseType_create(
112
const axutil_env_t *env)
114
adb_ncTerminateInstanceResponseType_t *_ncTerminateInstanceResponseType = NULL;
116
AXIS2_ENV_CHECK(env, NULL);
118
_ncTerminateInstanceResponseType = (adb_ncTerminateInstanceResponseType_t *) AXIS2_MALLOC(env->
119
allocator, sizeof(adb_ncTerminateInstanceResponseType_t));
121
if(NULL == _ncTerminateInstanceResponseType)
123
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
127
memset(_ncTerminateInstanceResponseType, 0, sizeof(adb_ncTerminateInstanceResponseType_t));
129
_ncTerminateInstanceResponseType->property_correlationId = NULL;
130
_ncTerminateInstanceResponseType->is_valid_correlationId = AXIS2_FALSE;
131
_ncTerminateInstanceResponseType->property_userId = NULL;
132
_ncTerminateInstanceResponseType->is_valid_userId = AXIS2_FALSE;
133
_ncTerminateInstanceResponseType->is_valid_return = AXIS2_FALSE;
134
_ncTerminateInstanceResponseType->is_valid_statusMessage = AXIS2_FALSE;
135
_ncTerminateInstanceResponseType->property_instanceId = NULL;
136
_ncTerminateInstanceResponseType->is_valid_instanceId = AXIS2_FALSE;
137
_ncTerminateInstanceResponseType->property_shutdownState = NULL;
138
_ncTerminateInstanceResponseType->is_valid_shutdownState = AXIS2_FALSE;
139
_ncTerminateInstanceResponseType->property_previousState = NULL;
140
_ncTerminateInstanceResponseType->is_valid_previousState = AXIS2_FALSE;
143
return _ncTerminateInstanceResponseType;
146
axis2_status_t AXIS2_CALL
147
adb_ncTerminateInstanceResponseType_free (
148
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
149
const axutil_env_t *env)
153
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
154
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
156
adb_ncTerminateInstanceResponseType_reset_correlationId(_ncTerminateInstanceResponseType, env);
157
adb_ncTerminateInstanceResponseType_reset_userId(_ncTerminateInstanceResponseType, env);
158
adb_ncTerminateInstanceResponseType_reset_return(_ncTerminateInstanceResponseType, env);
159
adb_ncTerminateInstanceResponseType_reset_statusMessage(_ncTerminateInstanceResponseType, env);
160
adb_ncTerminateInstanceResponseType_reset_instanceId(_ncTerminateInstanceResponseType, env);
161
adb_ncTerminateInstanceResponseType_reset_shutdownState(_ncTerminateInstanceResponseType, env);
162
adb_ncTerminateInstanceResponseType_reset_previousState(_ncTerminateInstanceResponseType, env);
165
if(_ncTerminateInstanceResponseType)
167
AXIS2_FREE(env->allocator, _ncTerminateInstanceResponseType);
168
_ncTerminateInstanceResponseType = NULL;
170
return AXIS2_SUCCESS;
176
axis2_status_t AXIS2_CALL
177
adb_ncTerminateInstanceResponseType_deserialize(
178
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
179
const axutil_env_t *env,
180
axiom_node_t **dp_parent,
181
axis2_bool_t *dp_is_early_node_valid,
182
axis2_bool_t dont_care_minoccurs)
184
axiom_node_t *parent = *dp_parent;
186
axis2_status_t status = AXIS2_SUCCESS;
188
axis2_char_t* text_value = NULL;
189
axutil_qname_t *qname = NULL;
191
axutil_qname_t *element_qname = NULL;
193
axiom_node_t *first_node = NULL;
194
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
195
axiom_node_t *current_node = NULL;
196
axiom_element_t *current_element = NULL;
198
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
199
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
203
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
205
parent = axiom_node_get_next_sibling(parent, env);
209
/* This should be checked before everything */
210
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
211
"Failed in building adb object for ncTerminateInstanceResponseType : "
212
"NULL elemenet can not be passed to deserialize");
213
return AXIS2_FAILURE;
217
first_node = axiom_node_get_first_child(parent, env);
223
* building correlationId element
228
current_node = first_node;
229
is_early_node_valid = AXIS2_FALSE;
232
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
234
current_node = axiom_node_get_next_sibling(current_node, env);
236
if(current_node != NULL)
238
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
239
qname = axiom_element_get_qname(current_element, env, current_node);
242
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
246
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
248
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
250
is_early_node_valid = AXIS2_TRUE;
254
text_value = axiom_element_get_text(current_element, env, current_node);
255
if(text_value != NULL)
257
status = adb_ncTerminateInstanceResponseType_set_correlationId(_ncTerminateInstanceResponseType, env,
264
* axis2_qname_t *qname = NULL;
265
* axiom_attribute_t *the_attri = NULL;
267
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
268
* the_attri = axiom_element_get_attribute(current_element, env, qname);
270
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
272
axiom_attribute_t *the_attri = NULL;
273
axis2_char_t *attrib_text = NULL;
274
axutil_hash_t *attribute_hash = NULL;
276
attribute_hash = axiom_element_get_all_attributes(current_element, env);
281
axutil_hash_index_t *hi;
285
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
287
axutil_hash_this(hi, &key, NULL, &val);
289
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
291
the_attri = (axiom_attribute_t*)val;
299
attrib_text = axiom_attribute_get_value(the_attri, env);
303
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
304
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
307
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
309
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
310
status = AXIS2_FAILURE;
314
/* after all, we found this is a empty string */
315
status = adb_ncTerminateInstanceResponseType_set_correlationId(_ncTerminateInstanceResponseType, env,
320
if(AXIS2_FAILURE == status)
322
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
325
axutil_qname_free(element_qname, env);
327
return AXIS2_FAILURE;
333
axutil_qname_free(element_qname, env);
334
element_qname = NULL;
340
* building userId element
346
* because elements are ordered this works fine
350
if(current_node != NULL && is_early_node_valid)
352
current_node = axiom_node_get_next_sibling(current_node, env);
355
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
357
current_node = axiom_node_get_next_sibling(current_node, env);
359
if(current_node != NULL)
361
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
362
qname = axiom_element_get_qname(current_element, env, current_node);
366
is_early_node_valid = AXIS2_FALSE;
368
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
372
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
374
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
376
is_early_node_valid = AXIS2_TRUE;
380
text_value = axiom_element_get_text(current_element, env, current_node);
381
if(text_value != NULL)
383
status = adb_ncTerminateInstanceResponseType_set_userId(_ncTerminateInstanceResponseType, env,
390
* axis2_qname_t *qname = NULL;
391
* axiom_attribute_t *the_attri = NULL;
393
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
394
* the_attri = axiom_element_get_attribute(current_element, env, qname);
396
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
398
axiom_attribute_t *the_attri = NULL;
399
axis2_char_t *attrib_text = NULL;
400
axutil_hash_t *attribute_hash = NULL;
402
attribute_hash = axiom_element_get_all_attributes(current_element, env);
407
axutil_hash_index_t *hi;
411
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
413
axutil_hash_this(hi, &key, NULL, &val);
415
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
417
the_attri = (axiom_attribute_t*)val;
425
attrib_text = axiom_attribute_get_value(the_attri, env);
429
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
430
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
433
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
435
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
436
status = AXIS2_FAILURE;
440
/* after all, we found this is a empty string */
441
status = adb_ncTerminateInstanceResponseType_set_userId(_ncTerminateInstanceResponseType, env,
446
if(AXIS2_FAILURE == status)
448
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
451
axutil_qname_free(element_qname, env);
453
return AXIS2_FAILURE;
459
axutil_qname_free(element_qname, env);
460
element_qname = NULL;
466
* building return element
472
* because elements are ordered this works fine
476
if(current_node != NULL && is_early_node_valid)
478
current_node = axiom_node_get_next_sibling(current_node, env);
481
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
483
current_node = axiom_node_get_next_sibling(current_node, env);
485
if(current_node != NULL)
487
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
488
qname = axiom_element_get_qname(current_element, env, current_node);
492
is_early_node_valid = AXIS2_FALSE;
494
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
498
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
500
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
502
is_early_node_valid = AXIS2_TRUE;
506
text_value = axiom_element_get_text(current_element, env, current_node);
507
if(text_value != NULL)
509
if (!axutil_strcasecmp(text_value , "true"))
511
status = adb_ncTerminateInstanceResponseType_set_return(_ncTerminateInstanceResponseType, env,
516
status = adb_ncTerminateInstanceResponseType_set_return(_ncTerminateInstanceResponseType, env,
523
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
524
status = AXIS2_FAILURE;
527
if(AXIS2_FAILURE == status)
529
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
532
axutil_qname_free(element_qname, env);
534
return AXIS2_FAILURE;
540
axutil_qname_free(element_qname, env);
541
element_qname = NULL;
547
* building statusMessage element
553
* because elements are ordered this works fine
557
if(current_node != NULL && is_early_node_valid)
559
current_node = axiom_node_get_next_sibling(current_node, env);
562
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
564
current_node = axiom_node_get_next_sibling(current_node, env);
566
if(current_node != NULL)
568
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
569
qname = axiom_element_get_qname(current_element, env, current_node);
573
is_early_node_valid = AXIS2_FALSE;
575
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
579
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
581
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
583
is_early_node_valid = AXIS2_TRUE;
587
text_value = axiom_element_get_text(current_element, env, current_node);
588
if(text_value != NULL)
590
status = adb_ncTerminateInstanceResponseType_set_statusMessage(_ncTerminateInstanceResponseType, env,
594
if(AXIS2_FAILURE == status)
596
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
599
axutil_qname_free(element_qname, env);
601
return AXIS2_FAILURE;
607
axutil_qname_free(element_qname, env);
608
element_qname = NULL;
614
* building instanceId element
620
* because elements are ordered this works fine
624
if(current_node != NULL && is_early_node_valid)
626
current_node = axiom_node_get_next_sibling(current_node, env);
629
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
631
current_node = axiom_node_get_next_sibling(current_node, env);
633
if(current_node != NULL)
635
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
636
qname = axiom_element_get_qname(current_element, env, current_node);
640
is_early_node_valid = AXIS2_FALSE;
642
element_qname = axutil_qname_create(env, "instanceId", "http://eucalyptus.ucsb.edu/", NULL);
646
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
648
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
650
is_early_node_valid = AXIS2_TRUE;
654
text_value = axiom_element_get_text(current_element, env, current_node);
655
if(text_value != NULL)
657
status = adb_ncTerminateInstanceResponseType_set_instanceId(_ncTerminateInstanceResponseType, env,
664
* axis2_qname_t *qname = NULL;
665
* axiom_attribute_t *the_attri = NULL;
667
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
668
* the_attri = axiom_element_get_attribute(current_element, env, qname);
670
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
672
axiom_attribute_t *the_attri = NULL;
673
axis2_char_t *attrib_text = NULL;
674
axutil_hash_t *attribute_hash = NULL;
676
attribute_hash = axiom_element_get_all_attributes(current_element, env);
681
axutil_hash_index_t *hi;
685
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
687
axutil_hash_this(hi, &key, NULL, &val);
689
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
691
the_attri = (axiom_attribute_t*)val;
699
attrib_text = axiom_attribute_get_value(the_attri, env);
703
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
704
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
707
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
709
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceId");
710
status = AXIS2_FAILURE;
714
/* after all, we found this is a empty string */
715
status = adb_ncTerminateInstanceResponseType_set_instanceId(_ncTerminateInstanceResponseType, env,
720
if(AXIS2_FAILURE == status)
722
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceId ");
725
axutil_qname_free(element_qname, env);
727
return AXIS2_FAILURE;
731
else if(!dont_care_minoccurs)
735
axutil_qname_free(element_qname, env);
737
/* this is not a nillable element*/
738
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element instanceId missing");
739
return AXIS2_FAILURE;
744
axutil_qname_free(element_qname, env);
745
element_qname = NULL;
751
* building shutdownState element
757
* because elements are ordered this works fine
761
if(current_node != NULL && is_early_node_valid)
763
current_node = axiom_node_get_next_sibling(current_node, env);
766
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
768
current_node = axiom_node_get_next_sibling(current_node, env);
770
if(current_node != NULL)
772
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
773
qname = axiom_element_get_qname(current_element, env, current_node);
777
is_early_node_valid = AXIS2_FALSE;
779
element_qname = axutil_qname_create(env, "shutdownState", "http://eucalyptus.ucsb.edu/", NULL);
783
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
785
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
787
is_early_node_valid = AXIS2_TRUE;
791
text_value = axiom_element_get_text(current_element, env, current_node);
792
if(text_value != NULL)
794
status = adb_ncTerminateInstanceResponseType_set_shutdownState(_ncTerminateInstanceResponseType, env,
801
* axis2_qname_t *qname = NULL;
802
* axiom_attribute_t *the_attri = NULL;
804
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
805
* the_attri = axiom_element_get_attribute(current_element, env, qname);
807
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
809
axiom_attribute_t *the_attri = NULL;
810
axis2_char_t *attrib_text = NULL;
811
axutil_hash_t *attribute_hash = NULL;
813
attribute_hash = axiom_element_get_all_attributes(current_element, env);
818
axutil_hash_index_t *hi;
822
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
824
axutil_hash_this(hi, &key, NULL, &val);
826
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
828
the_attri = (axiom_attribute_t*)val;
836
attrib_text = axiom_attribute_get_value(the_attri, env);
840
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
841
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
844
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
846
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element shutdownState");
847
status = AXIS2_FAILURE;
851
/* after all, we found this is a empty string */
852
status = adb_ncTerminateInstanceResponseType_set_shutdownState(_ncTerminateInstanceResponseType, env,
857
if(AXIS2_FAILURE == status)
859
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for shutdownState ");
862
axutil_qname_free(element_qname, env);
864
return AXIS2_FAILURE;
870
axutil_qname_free(element_qname, env);
871
element_qname = NULL;
877
* building previousState element
883
* because elements are ordered this works fine
887
if(current_node != NULL && is_early_node_valid)
889
current_node = axiom_node_get_next_sibling(current_node, env);
892
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
894
current_node = axiom_node_get_next_sibling(current_node, env);
896
if(current_node != NULL)
898
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
899
qname = axiom_element_get_qname(current_element, env, current_node);
903
is_early_node_valid = AXIS2_FALSE;
905
element_qname = axutil_qname_create(env, "previousState", "http://eucalyptus.ucsb.edu/", NULL);
909
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
911
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
913
is_early_node_valid = AXIS2_TRUE;
917
text_value = axiom_element_get_text(current_element, env, current_node);
918
if(text_value != NULL)
920
status = adb_ncTerminateInstanceResponseType_set_previousState(_ncTerminateInstanceResponseType, env,
927
* axis2_qname_t *qname = NULL;
928
* axiom_attribute_t *the_attri = NULL;
930
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
931
* the_attri = axiom_element_get_attribute(current_element, env, qname);
933
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
935
axiom_attribute_t *the_attri = NULL;
936
axis2_char_t *attrib_text = NULL;
937
axutil_hash_t *attribute_hash = NULL;
939
attribute_hash = axiom_element_get_all_attributes(current_element, env);
944
axutil_hash_index_t *hi;
948
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
950
axutil_hash_this(hi, &key, NULL, &val);
952
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
954
the_attri = (axiom_attribute_t*)val;
962
attrib_text = axiom_attribute_get_value(the_attri, env);
966
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
967
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
970
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
972
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element previousState");
973
status = AXIS2_FAILURE;
977
/* after all, we found this is a empty string */
978
status = adb_ncTerminateInstanceResponseType_set_previousState(_ncTerminateInstanceResponseType, env,
983
if(AXIS2_FAILURE == status)
985
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for previousState ");
988
axutil_qname_free(element_qname, env);
990
return AXIS2_FAILURE;
996
axutil_qname_free(element_qname, env);
997
element_qname = NULL;
1003
axis2_bool_t AXIS2_CALL
1004
adb_ncTerminateInstanceResponseType_is_particle()
1013
adb_ncTerminateInstanceResponseType_declare_parent_namespaces(
1014
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1015
const axutil_env_t *env, axiom_element_t *parent_element,
1016
axutil_hash_t *namespaces, int *next_ns_index)
1019
/* Here this is an empty function, Nothing to declare */
1025
axiom_node_t* AXIS2_CALL
1026
adb_ncTerminateInstanceResponseType_serialize(
1027
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1028
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)
1032
axis2_char_t *string_to_stream;
1035
axiom_node_t *current_node = NULL;
1040
axiom_namespace_t *ns1 = NULL;
1042
axis2_char_t *qname_uri = NULL;
1043
axis2_char_t *qname_prefix = NULL;
1044
axis2_char_t *p_prefix = NULL;
1045
axis2_bool_t ns_already_defined;
1047
axis2_char_t *text_value_1;
1048
axis2_char_t *text_value_1_temp;
1050
axis2_char_t *text_value_2;
1051
axis2_char_t *text_value_2_temp;
1053
axis2_char_t text_value_3[64];
1055
axis2_char_t text_value_4[64];
1057
axis2_char_t *text_value_5;
1058
axis2_char_t *text_value_5_temp;
1060
axis2_char_t *text_value_6;
1061
axis2_char_t *text_value_6_temp;
1063
axis2_char_t *text_value_7;
1064
axis2_char_t *text_value_7_temp;
1066
axis2_char_t *start_input_str = NULL;
1067
axis2_char_t *end_input_str = NULL;
1068
unsigned int start_input_str_len = 0;
1069
unsigned int end_input_str_len = 0;
1072
axiom_data_source_t *data_source = NULL;
1073
axutil_stream_t *stream = NULL;
1077
AXIS2_ENV_CHECK(env, NULL);
1078
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
1081
current_node = parent;
1082
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1085
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1089
if(!parent_tag_closed)
1092
string_to_stream = ">";
1093
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1098
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1100
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1101
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1102
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1104
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1105
"http://eucalyptus.ucsb.edu/",
1110
if (!_ncTerminateInstanceResponseType->is_valid_correlationId)
1113
/* no need to complain for minoccurs=0 element */
1119
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1120
(4 + axutil_strlen(p_prefix) +
1121
axutil_strlen("correlationId")));
1123
/* axutil_strlen("<:>") + 1 = 4 */
1124
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1125
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1126
/* axutil_strlen("</:>") + 1 = 5 */
1134
* parsing correlationId element
1139
sprintf(start_input_str, "<%s%scorrelationId>",
1140
p_prefix?p_prefix:"",
1141
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1143
start_input_str_len = axutil_strlen(start_input_str);
1144
sprintf(end_input_str, "</%s%scorrelationId>",
1145
p_prefix?p_prefix:"",
1146
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1147
end_input_str_len = axutil_strlen(end_input_str);
1149
text_value_1 = _ncTerminateInstanceResponseType->property_correlationId;
1151
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1154
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1155
if (text_value_1_temp)
1157
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1158
AXIS2_FREE(env->allocator, text_value_1_temp);
1162
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1165
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1168
AXIS2_FREE(env->allocator,start_input_str);
1169
AXIS2_FREE(env->allocator,end_input_str);
1173
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1175
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1176
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1177
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1179
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1180
"http://eucalyptus.ucsb.edu/",
1185
if (!_ncTerminateInstanceResponseType->is_valid_userId)
1188
/* no need to complain for minoccurs=0 element */
1194
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1195
(4 + axutil_strlen(p_prefix) +
1196
axutil_strlen("userId")));
1198
/* axutil_strlen("<:>") + 1 = 4 */
1199
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1200
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1201
/* axutil_strlen("</:>") + 1 = 5 */
1209
* parsing userId element
1214
sprintf(start_input_str, "<%s%suserId>",
1215
p_prefix?p_prefix:"",
1216
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1218
start_input_str_len = axutil_strlen(start_input_str);
1219
sprintf(end_input_str, "</%s%suserId>",
1220
p_prefix?p_prefix:"",
1221
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1222
end_input_str_len = axutil_strlen(end_input_str);
1224
text_value_2 = _ncTerminateInstanceResponseType->property_userId;
1226
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1229
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1230
if (text_value_2_temp)
1232
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1233
AXIS2_FREE(env->allocator, text_value_2_temp);
1237
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1240
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1243
AXIS2_FREE(env->allocator,start_input_str);
1244
AXIS2_FREE(env->allocator,end_input_str);
1248
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1250
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1251
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1252
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1254
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1255
"http://eucalyptus.ucsb.edu/",
1260
if (!_ncTerminateInstanceResponseType->is_valid_return)
1263
/* no need to complain for minoccurs=0 element */
1269
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1270
(4 + axutil_strlen(p_prefix) +
1271
axutil_strlen("return")));
1273
/* axutil_strlen("<:>") + 1 = 4 */
1274
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1275
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1276
/* axutil_strlen("</:>") + 1 = 5 */
1284
* parsing return element
1289
sprintf(start_input_str, "<%s%sreturn>",
1290
p_prefix?p_prefix:"",
1291
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1293
start_input_str_len = axutil_strlen(start_input_str);
1294
sprintf(end_input_str, "</%s%sreturn>",
1295
p_prefix?p_prefix:"",
1296
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1297
end_input_str_len = axutil_strlen(end_input_str);
1299
strcpy(text_value_3, (_ncTerminateInstanceResponseType->property_return)?"true":"false");
1301
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1303
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1305
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1308
AXIS2_FREE(env->allocator,start_input_str);
1309
AXIS2_FREE(env->allocator,end_input_str);
1313
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1315
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1316
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1317
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1319
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1320
"http://eucalyptus.ucsb.edu/",
1325
if (!_ncTerminateInstanceResponseType->is_valid_statusMessage)
1328
/* no need to complain for minoccurs=0 element */
1334
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1335
(4 + axutil_strlen(p_prefix) +
1336
axutil_strlen("statusMessage")));
1338
/* axutil_strlen("<:>") + 1 = 4 */
1339
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1340
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1341
/* axutil_strlen("</:>") + 1 = 5 */
1349
* parsing statusMessage element
1354
sprintf(start_input_str, "<%s%sstatusMessage>",
1355
p_prefix?p_prefix:"",
1356
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1358
start_input_str_len = axutil_strlen(start_input_str);
1359
sprintf(end_input_str, "</%s%sstatusMessage>",
1360
p_prefix?p_prefix:"",
1361
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1362
end_input_str_len = axutil_strlen(end_input_str);
1364
sprintf (text_value_4, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncTerminateInstanceResponseType->property_statusMessage);
1366
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1368
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1370
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1373
AXIS2_FREE(env->allocator,start_input_str);
1374
AXIS2_FREE(env->allocator,end_input_str);
1378
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1380
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1381
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1382
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1384
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1385
"http://eucalyptus.ucsb.edu/",
1390
if (!_ncTerminateInstanceResponseType->is_valid_instanceId)
1394
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property instanceId");
1400
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1401
(4 + axutil_strlen(p_prefix) +
1402
axutil_strlen("instanceId")));
1404
/* axutil_strlen("<:>") + 1 = 4 */
1405
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1406
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceId")));
1407
/* axutil_strlen("</:>") + 1 = 5 */
1415
* parsing instanceId element
1420
sprintf(start_input_str, "<%s%sinstanceId>",
1421
p_prefix?p_prefix:"",
1422
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1424
start_input_str_len = axutil_strlen(start_input_str);
1425
sprintf(end_input_str, "</%s%sinstanceId>",
1426
p_prefix?p_prefix:"",
1427
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1428
end_input_str_len = axutil_strlen(end_input_str);
1430
text_value_5 = _ncTerminateInstanceResponseType->property_instanceId;
1432
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1435
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1436
if (text_value_5_temp)
1438
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1439
AXIS2_FREE(env->allocator, text_value_5_temp);
1443
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1446
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1449
AXIS2_FREE(env->allocator,start_input_str);
1450
AXIS2_FREE(env->allocator,end_input_str);
1454
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1456
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1457
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1458
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1460
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1461
"http://eucalyptus.ucsb.edu/",
1466
if (!_ncTerminateInstanceResponseType->is_valid_shutdownState)
1469
/* no need to complain for minoccurs=0 element */
1475
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1476
(4 + axutil_strlen(p_prefix) +
1477
axutil_strlen("shutdownState")));
1479
/* axutil_strlen("<:>") + 1 = 4 */
1480
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1481
(5 + axutil_strlen(p_prefix) + axutil_strlen("shutdownState")));
1482
/* axutil_strlen("</:>") + 1 = 5 */
1490
* parsing shutdownState element
1495
sprintf(start_input_str, "<%s%sshutdownState>",
1496
p_prefix?p_prefix:"",
1497
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1499
start_input_str_len = axutil_strlen(start_input_str);
1500
sprintf(end_input_str, "</%s%sshutdownState>",
1501
p_prefix?p_prefix:"",
1502
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1503
end_input_str_len = axutil_strlen(end_input_str);
1505
text_value_6 = _ncTerminateInstanceResponseType->property_shutdownState;
1507
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1510
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1511
if (text_value_6_temp)
1513
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1514
AXIS2_FREE(env->allocator, text_value_6_temp);
1518
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1521
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1524
AXIS2_FREE(env->allocator,start_input_str);
1525
AXIS2_FREE(env->allocator,end_input_str);
1529
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1531
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1532
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1533
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1535
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1536
"http://eucalyptus.ucsb.edu/",
1541
if (!_ncTerminateInstanceResponseType->is_valid_previousState)
1544
/* no need to complain for minoccurs=0 element */
1550
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1551
(4 + axutil_strlen(p_prefix) +
1552
axutil_strlen("previousState")));
1554
/* axutil_strlen("<:>") + 1 = 4 */
1555
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1556
(5 + axutil_strlen(p_prefix) + axutil_strlen("previousState")));
1557
/* axutil_strlen("</:>") + 1 = 5 */
1565
* parsing previousState element
1570
sprintf(start_input_str, "<%s%spreviousState>",
1571
p_prefix?p_prefix:"",
1572
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1574
start_input_str_len = axutil_strlen(start_input_str);
1575
sprintf(end_input_str, "</%s%spreviousState>",
1576
p_prefix?p_prefix:"",
1577
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1578
end_input_str_len = axutil_strlen(end_input_str);
1580
text_value_7 = _ncTerminateInstanceResponseType->property_previousState;
1582
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1585
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1586
if (text_value_7_temp)
1588
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
1589
AXIS2_FREE(env->allocator, text_value_7_temp);
1593
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1596
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1599
AXIS2_FREE(env->allocator,start_input_str);
1600
AXIS2_FREE(env->allocator,end_input_str);
1612
* getter for correlationId.
1614
axis2_char_t* AXIS2_CALL
1615
adb_ncTerminateInstanceResponseType_get_correlationId(
1616
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1617
const axutil_env_t *env)
1620
AXIS2_ENV_CHECK(env, NULL);
1621
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
1624
return _ncTerminateInstanceResponseType->property_correlationId;
1628
* setter for correlationId
1630
axis2_status_t AXIS2_CALL
1631
adb_ncTerminateInstanceResponseType_set_correlationId(
1632
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1633
const axutil_env_t *env,
1634
const axis2_char_t* arg_correlationId)
1638
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1639
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1641
if(_ncTerminateInstanceResponseType->is_valid_correlationId &&
1642
arg_correlationId == _ncTerminateInstanceResponseType->property_correlationId)
1645
return AXIS2_SUCCESS;
1648
adb_ncTerminateInstanceResponseType_reset_correlationId(_ncTerminateInstanceResponseType, env);
1651
if(NULL == arg_correlationId)
1653
/* We are already done */
1654
return AXIS2_SUCCESS;
1656
_ncTerminateInstanceResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1657
if(NULL == _ncTerminateInstanceResponseType->property_correlationId)
1659
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1660
return AXIS2_FAILURE;
1662
_ncTerminateInstanceResponseType->is_valid_correlationId = AXIS2_TRUE;
1664
return AXIS2_SUCCESS;
1670
* resetter for correlationId
1672
axis2_status_t AXIS2_CALL
1673
adb_ncTerminateInstanceResponseType_reset_correlationId(
1674
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1675
const axutil_env_t *env)
1679
void *element = NULL;
1681
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1682
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1688
if(_ncTerminateInstanceResponseType->property_correlationId != NULL)
1692
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_correlationId);
1693
_ncTerminateInstanceResponseType->property_correlationId = NULL;
1698
_ncTerminateInstanceResponseType->is_valid_correlationId = AXIS2_FALSE;
1699
return AXIS2_SUCCESS;
1703
* Check whether correlationId is nill
1705
axis2_bool_t AXIS2_CALL
1706
adb_ncTerminateInstanceResponseType_is_correlationId_nil(
1707
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1708
const axutil_env_t *env)
1710
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1711
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
1713
return !_ncTerminateInstanceResponseType->is_valid_correlationId;
1717
* Set correlationId to nill (currently the same as reset)
1719
axis2_status_t AXIS2_CALL
1720
adb_ncTerminateInstanceResponseType_set_correlationId_nil(
1721
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1722
const axutil_env_t *env)
1724
return adb_ncTerminateInstanceResponseType_reset_correlationId(_ncTerminateInstanceResponseType, env);
1730
* getter for userId.
1732
axis2_char_t* AXIS2_CALL
1733
adb_ncTerminateInstanceResponseType_get_userId(
1734
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1735
const axutil_env_t *env)
1738
AXIS2_ENV_CHECK(env, NULL);
1739
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
1742
return _ncTerminateInstanceResponseType->property_userId;
1748
axis2_status_t AXIS2_CALL
1749
adb_ncTerminateInstanceResponseType_set_userId(
1750
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1751
const axutil_env_t *env,
1752
const axis2_char_t* arg_userId)
1756
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1757
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1759
if(_ncTerminateInstanceResponseType->is_valid_userId &&
1760
arg_userId == _ncTerminateInstanceResponseType->property_userId)
1763
return AXIS2_SUCCESS;
1766
adb_ncTerminateInstanceResponseType_reset_userId(_ncTerminateInstanceResponseType, env);
1769
if(NULL == arg_userId)
1771
/* We are already done */
1772
return AXIS2_SUCCESS;
1774
_ncTerminateInstanceResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1775
if(NULL == _ncTerminateInstanceResponseType->property_userId)
1777
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1778
return AXIS2_FAILURE;
1780
_ncTerminateInstanceResponseType->is_valid_userId = AXIS2_TRUE;
1782
return AXIS2_SUCCESS;
1788
* resetter for userId
1790
axis2_status_t AXIS2_CALL
1791
adb_ncTerminateInstanceResponseType_reset_userId(
1792
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1793
const axutil_env_t *env)
1797
void *element = NULL;
1799
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1800
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1806
if(_ncTerminateInstanceResponseType->property_userId != NULL)
1810
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_userId);
1811
_ncTerminateInstanceResponseType->property_userId = NULL;
1816
_ncTerminateInstanceResponseType->is_valid_userId = AXIS2_FALSE;
1817
return AXIS2_SUCCESS;
1821
* Check whether userId is nill
1823
axis2_bool_t AXIS2_CALL
1824
adb_ncTerminateInstanceResponseType_is_userId_nil(
1825
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1826
const axutil_env_t *env)
1828
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1829
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
1831
return !_ncTerminateInstanceResponseType->is_valid_userId;
1835
* Set userId to nill (currently the same as reset)
1837
axis2_status_t AXIS2_CALL
1838
adb_ncTerminateInstanceResponseType_set_userId_nil(
1839
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1840
const axutil_env_t *env)
1842
return adb_ncTerminateInstanceResponseType_reset_userId(_ncTerminateInstanceResponseType, env);
1848
* getter for return.
1850
axis2_bool_t AXIS2_CALL
1851
adb_ncTerminateInstanceResponseType_get_return(
1852
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1853
const axutil_env_t *env)
1856
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1857
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, (axis2_bool_t)0);
1860
return _ncTerminateInstanceResponseType->property_return;
1866
axis2_status_t AXIS2_CALL
1867
adb_ncTerminateInstanceResponseType_set_return(
1868
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1869
const axutil_env_t *env,
1870
axis2_bool_t arg_return)
1874
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1875
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1877
if(_ncTerminateInstanceResponseType->is_valid_return &&
1878
arg_return == _ncTerminateInstanceResponseType->property_return)
1881
return AXIS2_SUCCESS;
1884
adb_ncTerminateInstanceResponseType_reset_return(_ncTerminateInstanceResponseType, env);
1886
_ncTerminateInstanceResponseType->property_return = arg_return;
1887
_ncTerminateInstanceResponseType->is_valid_return = AXIS2_TRUE;
1889
return AXIS2_SUCCESS;
1895
* resetter for return
1897
axis2_status_t AXIS2_CALL
1898
adb_ncTerminateInstanceResponseType_reset_return(
1899
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1900
const axutil_env_t *env)
1904
void *element = NULL;
1906
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1907
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1910
_ncTerminateInstanceResponseType->is_valid_return = AXIS2_FALSE;
1911
return AXIS2_SUCCESS;
1915
* Check whether return is nill
1917
axis2_bool_t AXIS2_CALL
1918
adb_ncTerminateInstanceResponseType_is_return_nil(
1919
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1920
const axutil_env_t *env)
1922
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1923
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
1925
return !_ncTerminateInstanceResponseType->is_valid_return;
1929
* Set return to nill (currently the same as reset)
1931
axis2_status_t AXIS2_CALL
1932
adb_ncTerminateInstanceResponseType_set_return_nil(
1933
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1934
const axutil_env_t *env)
1936
return adb_ncTerminateInstanceResponseType_reset_return(_ncTerminateInstanceResponseType, env);
1942
* getter for statusMessage.
1945
adb_ncTerminateInstanceResponseType_get_statusMessage(
1946
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1947
const axutil_env_t *env)
1950
AXIS2_ENV_CHECK(env, (int)0);
1951
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, (int)0);
1954
return _ncTerminateInstanceResponseType->property_statusMessage;
1958
* setter for statusMessage
1960
axis2_status_t AXIS2_CALL
1961
adb_ncTerminateInstanceResponseType_set_statusMessage(
1962
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1963
const axutil_env_t *env,
1964
const int arg_statusMessage)
1968
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1969
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1971
if(_ncTerminateInstanceResponseType->is_valid_statusMessage &&
1972
arg_statusMessage == _ncTerminateInstanceResponseType->property_statusMessage)
1975
return AXIS2_SUCCESS;
1978
adb_ncTerminateInstanceResponseType_reset_statusMessage(_ncTerminateInstanceResponseType, env);
1980
_ncTerminateInstanceResponseType->property_statusMessage = arg_statusMessage;
1981
_ncTerminateInstanceResponseType->is_valid_statusMessage = AXIS2_TRUE;
1983
return AXIS2_SUCCESS;
1989
* resetter for statusMessage
1991
axis2_status_t AXIS2_CALL
1992
adb_ncTerminateInstanceResponseType_reset_statusMessage(
1993
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1994
const axutil_env_t *env)
1998
void *element = NULL;
2000
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2001
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2004
_ncTerminateInstanceResponseType->is_valid_statusMessage = AXIS2_FALSE;
2005
return AXIS2_SUCCESS;
2009
* Check whether statusMessage is nill
2011
axis2_bool_t AXIS2_CALL
2012
adb_ncTerminateInstanceResponseType_is_statusMessage_nil(
2013
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2014
const axutil_env_t *env)
2016
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2017
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2019
return !_ncTerminateInstanceResponseType->is_valid_statusMessage;
2023
* Set statusMessage to nill (currently the same as reset)
2025
axis2_status_t AXIS2_CALL
2026
adb_ncTerminateInstanceResponseType_set_statusMessage_nil(
2027
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2028
const axutil_env_t *env)
2030
return adb_ncTerminateInstanceResponseType_reset_statusMessage(_ncTerminateInstanceResponseType, env);
2036
* getter for instanceId.
2038
axis2_char_t* AXIS2_CALL
2039
adb_ncTerminateInstanceResponseType_get_instanceId(
2040
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2041
const axutil_env_t *env)
2044
AXIS2_ENV_CHECK(env, NULL);
2045
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
2048
return _ncTerminateInstanceResponseType->property_instanceId;
2052
* setter for instanceId
2054
axis2_status_t AXIS2_CALL
2055
adb_ncTerminateInstanceResponseType_set_instanceId(
2056
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2057
const axutil_env_t *env,
2058
const axis2_char_t* arg_instanceId)
2062
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2063
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2065
if(_ncTerminateInstanceResponseType->is_valid_instanceId &&
2066
arg_instanceId == _ncTerminateInstanceResponseType->property_instanceId)
2069
return AXIS2_SUCCESS;
2073
if(NULL == arg_instanceId)
2075
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceId is being set to NULL, but it is not a nullable element");
2076
return AXIS2_FAILURE;
2078
adb_ncTerminateInstanceResponseType_reset_instanceId(_ncTerminateInstanceResponseType, env);
2081
if(NULL == arg_instanceId)
2083
/* We are already done */
2084
return AXIS2_SUCCESS;
2086
_ncTerminateInstanceResponseType->property_instanceId = (axis2_char_t *)axutil_strdup(env, arg_instanceId);
2087
if(NULL == _ncTerminateInstanceResponseType->property_instanceId)
2089
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for instanceId");
2090
return AXIS2_FAILURE;
2092
_ncTerminateInstanceResponseType->is_valid_instanceId = AXIS2_TRUE;
2094
return AXIS2_SUCCESS;
2100
* resetter for instanceId
2102
axis2_status_t AXIS2_CALL
2103
adb_ncTerminateInstanceResponseType_reset_instanceId(
2104
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2105
const axutil_env_t *env)
2109
void *element = NULL;
2111
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2112
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2118
if(_ncTerminateInstanceResponseType->property_instanceId != NULL)
2122
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_instanceId);
2123
_ncTerminateInstanceResponseType->property_instanceId = NULL;
2128
_ncTerminateInstanceResponseType->is_valid_instanceId = AXIS2_FALSE;
2129
return AXIS2_SUCCESS;
2133
* Check whether instanceId is nill
2135
axis2_bool_t AXIS2_CALL
2136
adb_ncTerminateInstanceResponseType_is_instanceId_nil(
2137
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2138
const axutil_env_t *env)
2140
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2141
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2143
return !_ncTerminateInstanceResponseType->is_valid_instanceId;
2147
* Set instanceId to nill (currently the same as reset)
2149
axis2_status_t AXIS2_CALL
2150
adb_ncTerminateInstanceResponseType_set_instanceId_nil(
2151
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2152
const axutil_env_t *env)
2154
return adb_ncTerminateInstanceResponseType_reset_instanceId(_ncTerminateInstanceResponseType, env);
2160
* getter for shutdownState.
2162
axis2_char_t* AXIS2_CALL
2163
adb_ncTerminateInstanceResponseType_get_shutdownState(
2164
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2165
const axutil_env_t *env)
2168
AXIS2_ENV_CHECK(env, NULL);
2169
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
2172
return _ncTerminateInstanceResponseType->property_shutdownState;
2176
* setter for shutdownState
2178
axis2_status_t AXIS2_CALL
2179
adb_ncTerminateInstanceResponseType_set_shutdownState(
2180
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2181
const axutil_env_t *env,
2182
const axis2_char_t* arg_shutdownState)
2186
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2187
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2189
if(_ncTerminateInstanceResponseType->is_valid_shutdownState &&
2190
arg_shutdownState == _ncTerminateInstanceResponseType->property_shutdownState)
2193
return AXIS2_SUCCESS;
2196
adb_ncTerminateInstanceResponseType_reset_shutdownState(_ncTerminateInstanceResponseType, env);
2199
if(NULL == arg_shutdownState)
2201
/* We are already done */
2202
return AXIS2_SUCCESS;
2204
_ncTerminateInstanceResponseType->property_shutdownState = (axis2_char_t *)axutil_strdup(env, arg_shutdownState);
2205
if(NULL == _ncTerminateInstanceResponseType->property_shutdownState)
2207
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for shutdownState");
2208
return AXIS2_FAILURE;
2210
_ncTerminateInstanceResponseType->is_valid_shutdownState = AXIS2_TRUE;
2212
return AXIS2_SUCCESS;
2218
* resetter for shutdownState
2220
axis2_status_t AXIS2_CALL
2221
adb_ncTerminateInstanceResponseType_reset_shutdownState(
2222
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2223
const axutil_env_t *env)
2227
void *element = NULL;
2229
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2230
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2236
if(_ncTerminateInstanceResponseType->property_shutdownState != NULL)
2240
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_shutdownState);
2241
_ncTerminateInstanceResponseType->property_shutdownState = NULL;
2246
_ncTerminateInstanceResponseType->is_valid_shutdownState = AXIS2_FALSE;
2247
return AXIS2_SUCCESS;
2251
* Check whether shutdownState is nill
2253
axis2_bool_t AXIS2_CALL
2254
adb_ncTerminateInstanceResponseType_is_shutdownState_nil(
2255
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2256
const axutil_env_t *env)
2258
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2259
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2261
return !_ncTerminateInstanceResponseType->is_valid_shutdownState;
2265
* Set shutdownState to nill (currently the same as reset)
2267
axis2_status_t AXIS2_CALL
2268
adb_ncTerminateInstanceResponseType_set_shutdownState_nil(
2269
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2270
const axutil_env_t *env)
2272
return adb_ncTerminateInstanceResponseType_reset_shutdownState(_ncTerminateInstanceResponseType, env);
2278
* getter for previousState.
2280
axis2_char_t* AXIS2_CALL
2281
adb_ncTerminateInstanceResponseType_get_previousState(
2282
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2283
const axutil_env_t *env)
2286
AXIS2_ENV_CHECK(env, NULL);
2287
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
2290
return _ncTerminateInstanceResponseType->property_previousState;
2294
* setter for previousState
2296
axis2_status_t AXIS2_CALL
2297
adb_ncTerminateInstanceResponseType_set_previousState(
2298
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2299
const axutil_env_t *env,
2300
const axis2_char_t* arg_previousState)
2304
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2305
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2307
if(_ncTerminateInstanceResponseType->is_valid_previousState &&
2308
arg_previousState == _ncTerminateInstanceResponseType->property_previousState)
2311
return AXIS2_SUCCESS;
2314
adb_ncTerminateInstanceResponseType_reset_previousState(_ncTerminateInstanceResponseType, env);
2317
if(NULL == arg_previousState)
2319
/* We are already done */
2320
return AXIS2_SUCCESS;
2322
_ncTerminateInstanceResponseType->property_previousState = (axis2_char_t *)axutil_strdup(env, arg_previousState);
2323
if(NULL == _ncTerminateInstanceResponseType->property_previousState)
2325
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for previousState");
2326
return AXIS2_FAILURE;
2328
_ncTerminateInstanceResponseType->is_valid_previousState = AXIS2_TRUE;
2330
return AXIS2_SUCCESS;
2336
* resetter for previousState
2338
axis2_status_t AXIS2_CALL
2339
adb_ncTerminateInstanceResponseType_reset_previousState(
2340
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2341
const axutil_env_t *env)
2345
void *element = NULL;
2347
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2348
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2354
if(_ncTerminateInstanceResponseType->property_previousState != NULL)
2358
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_previousState);
2359
_ncTerminateInstanceResponseType->property_previousState = NULL;
2364
_ncTerminateInstanceResponseType->is_valid_previousState = AXIS2_FALSE;
2365
return AXIS2_SUCCESS;
2369
* Check whether previousState is nill
2371
axis2_bool_t AXIS2_CALL
2372
adb_ncTerminateInstanceResponseType_is_previousState_nil(
2373
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2374
const axutil_env_t *env)
2376
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2377
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2379
return !_ncTerminateInstanceResponseType->is_valid_previousState;
2383
* Set previousState to nill (currently the same as reset)
2385
axis2_status_t AXIS2_CALL
2386
adb_ncTerminateInstanceResponseType_set_previousState_nil(
2387
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2388
const axutil_env_t *env)
2390
return adb_ncTerminateInstanceResponseType_reset_previousState(_ncTerminateInstanceResponseType, env);