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
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_shutdownState;
62
axis2_bool_t is_valid_shutdownState;
65
axis2_char_t* property_previousState;
68
axis2_bool_t is_valid_previousState;
75
/************************* Private Function prototypes ********************************/
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->property_nodeName = NULL;
135
_ncTerminateInstanceResponseType->is_valid_nodeName = AXIS2_FALSE;
136
_ncTerminateInstanceResponseType->is_valid_statusMessage = AXIS2_FALSE;
137
_ncTerminateInstanceResponseType->property_instanceId = NULL;
138
_ncTerminateInstanceResponseType->is_valid_instanceId = AXIS2_FALSE;
139
_ncTerminateInstanceResponseType->property_shutdownState = NULL;
140
_ncTerminateInstanceResponseType->is_valid_shutdownState = AXIS2_FALSE;
141
_ncTerminateInstanceResponseType->property_previousState = NULL;
142
_ncTerminateInstanceResponseType->is_valid_previousState = AXIS2_FALSE;
145
return _ncTerminateInstanceResponseType;
148
axis2_status_t AXIS2_CALL
149
adb_ncTerminateInstanceResponseType_free (
150
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
151
const axutil_env_t *env)
155
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
156
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
158
adb_ncTerminateInstanceResponseType_reset_correlationId(_ncTerminateInstanceResponseType, env);
159
adb_ncTerminateInstanceResponseType_reset_userId(_ncTerminateInstanceResponseType, env);
160
adb_ncTerminateInstanceResponseType_reset_return(_ncTerminateInstanceResponseType, env);
161
adb_ncTerminateInstanceResponseType_reset_nodeName(_ncTerminateInstanceResponseType, env);
162
adb_ncTerminateInstanceResponseType_reset_statusMessage(_ncTerminateInstanceResponseType, env);
163
adb_ncTerminateInstanceResponseType_reset_instanceId(_ncTerminateInstanceResponseType, env);
164
adb_ncTerminateInstanceResponseType_reset_shutdownState(_ncTerminateInstanceResponseType, env);
165
adb_ncTerminateInstanceResponseType_reset_previousState(_ncTerminateInstanceResponseType, env);
168
if(_ncTerminateInstanceResponseType)
170
AXIS2_FREE(env->allocator, _ncTerminateInstanceResponseType);
171
_ncTerminateInstanceResponseType = NULL;
173
return AXIS2_SUCCESS;
179
axis2_status_t AXIS2_CALL
180
adb_ncTerminateInstanceResponseType_deserialize(
181
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
182
const axutil_env_t *env,
183
axiom_node_t **dp_parent,
184
axis2_bool_t *dp_is_early_node_valid,
185
axis2_bool_t dont_care_minoccurs)
187
axiom_node_t *parent = *dp_parent;
189
axis2_status_t status = AXIS2_SUCCESS;
191
axis2_char_t* text_value = NULL;
192
axutil_qname_t *qname = NULL;
194
axutil_qname_t *element_qname = NULL;
196
axiom_node_t *first_node = NULL;
197
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
198
axiom_node_t *current_node = NULL;
199
axiom_element_t *current_element = NULL;
201
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
202
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
206
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
208
parent = axiom_node_get_next_sibling(parent, env);
212
/* This should be checked before everything */
213
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
214
"Failed in building adb object for ncTerminateInstanceResponseType : "
215
"NULL elemenet can not be passed to deserialize");
216
return AXIS2_FAILURE;
220
first_node = axiom_node_get_first_child(parent, env);
226
* building correlationId element
231
current_node = first_node;
232
is_early_node_valid = AXIS2_FALSE;
235
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
237
current_node = axiom_node_get_next_sibling(current_node, env);
239
if(current_node != NULL)
241
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
242
qname = axiom_element_get_qname(current_element, env, current_node);
245
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
249
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
251
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
253
is_early_node_valid = AXIS2_TRUE;
257
text_value = axiom_element_get_text(current_element, env, current_node);
258
if(text_value != NULL)
260
status = adb_ncTerminateInstanceResponseType_set_correlationId(_ncTerminateInstanceResponseType, env,
264
if(AXIS2_FAILURE == status)
266
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
269
axutil_qname_free(element_qname, env);
271
return AXIS2_FAILURE;
277
axutil_qname_free(element_qname, env);
278
element_qname = NULL;
284
* building userId element
290
* because elements are ordered this works fine
294
if(current_node != NULL && is_early_node_valid)
296
current_node = axiom_node_get_next_sibling(current_node, env);
299
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
301
current_node = axiom_node_get_next_sibling(current_node, env);
303
if(current_node != NULL)
305
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
306
qname = axiom_element_get_qname(current_element, env, current_node);
310
is_early_node_valid = AXIS2_FALSE;
312
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
316
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
318
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
320
is_early_node_valid = AXIS2_TRUE;
324
text_value = axiom_element_get_text(current_element, env, current_node);
325
if(text_value != NULL)
327
status = adb_ncTerminateInstanceResponseType_set_userId(_ncTerminateInstanceResponseType, env,
334
* axis2_qname_t *qname = NULL;
335
* axiom_attribute_t *the_attri = NULL;
337
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
338
* the_attri = axiom_element_get_attribute(current_element, env, qname);
340
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
342
axiom_attribute_t *the_attri = NULL;
343
axis2_char_t *attrib_text = NULL;
344
axutil_hash_t *attribute_hash = NULL;
346
attribute_hash = axiom_element_get_all_attributes(current_element, env);
351
axutil_hash_index_t *hi;
355
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
357
axutil_hash_this(hi, &key, NULL, &val);
359
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
361
the_attri = (axiom_attribute_t*)val;
369
attrib_text = axiom_attribute_get_value(the_attri, env);
373
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
374
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
377
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
379
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
380
status = AXIS2_FAILURE;
384
/* after all, we found this is a empty string */
385
status = adb_ncTerminateInstanceResponseType_set_userId(_ncTerminateInstanceResponseType, env,
390
if(AXIS2_FAILURE == status)
392
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
395
axutil_qname_free(element_qname, env);
397
return AXIS2_FAILURE;
403
axutil_qname_free(element_qname, env);
404
element_qname = NULL;
410
* building return element
416
* because elements are ordered this works fine
420
if(current_node != NULL && is_early_node_valid)
422
current_node = axiom_node_get_next_sibling(current_node, env);
425
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
427
current_node = axiom_node_get_next_sibling(current_node, env);
429
if(current_node != NULL)
431
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
432
qname = axiom_element_get_qname(current_element, env, current_node);
436
is_early_node_valid = AXIS2_FALSE;
438
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
442
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
444
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
446
is_early_node_valid = AXIS2_TRUE;
450
text_value = axiom_element_get_text(current_element, env, current_node);
451
if(text_value != NULL)
453
if (!axutil_strcasecmp(text_value , "true"))
455
status = adb_ncTerminateInstanceResponseType_set_return(_ncTerminateInstanceResponseType, env,
460
status = adb_ncTerminateInstanceResponseType_set_return(_ncTerminateInstanceResponseType, env,
467
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
468
status = AXIS2_FAILURE;
471
if(AXIS2_FAILURE == status)
473
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
476
axutil_qname_free(element_qname, env);
478
return AXIS2_FAILURE;
484
axutil_qname_free(element_qname, env);
485
element_qname = NULL;
491
* building nodeName element
497
* because elements are ordered this works fine
501
if(current_node != NULL && is_early_node_valid)
503
current_node = axiom_node_get_next_sibling(current_node, env);
506
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
508
current_node = axiom_node_get_next_sibling(current_node, env);
510
if(current_node != NULL)
512
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
513
qname = axiom_element_get_qname(current_element, env, current_node);
517
is_early_node_valid = AXIS2_FALSE;
519
element_qname = axutil_qname_create(env, "nodeName", "http://eucalyptus.ucsb.edu/", NULL);
523
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
525
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
527
is_early_node_valid = AXIS2_TRUE;
531
text_value = axiom_element_get_text(current_element, env, current_node);
532
if(text_value != NULL)
534
status = adb_ncTerminateInstanceResponseType_set_nodeName(_ncTerminateInstanceResponseType, env,
538
if(AXIS2_FAILURE == status)
540
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeName ");
543
axutil_qname_free(element_qname, env);
545
return AXIS2_FAILURE;
551
axutil_qname_free(element_qname, env);
552
element_qname = NULL;
558
* building statusMessage element
564
* because elements are ordered this works fine
568
if(current_node != NULL && is_early_node_valid)
570
current_node = axiom_node_get_next_sibling(current_node, env);
573
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
575
current_node = axiom_node_get_next_sibling(current_node, env);
577
if(current_node != NULL)
579
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
580
qname = axiom_element_get_qname(current_element, env, current_node);
584
is_early_node_valid = AXIS2_FALSE;
586
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
590
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
592
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
594
is_early_node_valid = AXIS2_TRUE;
598
text_value = axiom_element_get_text(current_element, env, current_node);
599
if(text_value != NULL)
601
status = adb_ncTerminateInstanceResponseType_set_statusMessage(_ncTerminateInstanceResponseType, env,
605
if(AXIS2_FAILURE == status)
607
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
610
axutil_qname_free(element_qname, env);
612
return AXIS2_FAILURE;
618
axutil_qname_free(element_qname, env);
619
element_qname = NULL;
625
* building instanceId element
631
* because elements are ordered this works fine
635
if(current_node != NULL && is_early_node_valid)
637
current_node = axiom_node_get_next_sibling(current_node, env);
640
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
642
current_node = axiom_node_get_next_sibling(current_node, env);
644
if(current_node != NULL)
646
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
647
qname = axiom_element_get_qname(current_element, env, current_node);
651
is_early_node_valid = AXIS2_FALSE;
653
element_qname = axutil_qname_create(env, "instanceId", "http://eucalyptus.ucsb.edu/", NULL);
657
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
659
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
661
is_early_node_valid = AXIS2_TRUE;
665
text_value = axiom_element_get_text(current_element, env, current_node);
666
if(text_value != NULL)
668
status = adb_ncTerminateInstanceResponseType_set_instanceId(_ncTerminateInstanceResponseType, env,
675
* axis2_qname_t *qname = NULL;
676
* axiom_attribute_t *the_attri = NULL;
678
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
679
* the_attri = axiom_element_get_attribute(current_element, env, qname);
681
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
683
axiom_attribute_t *the_attri = NULL;
684
axis2_char_t *attrib_text = NULL;
685
axutil_hash_t *attribute_hash = NULL;
687
attribute_hash = axiom_element_get_all_attributes(current_element, env);
692
axutil_hash_index_t *hi;
696
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
698
axutil_hash_this(hi, &key, NULL, &val);
700
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
702
the_attri = (axiom_attribute_t*)val;
710
attrib_text = axiom_attribute_get_value(the_attri, env);
714
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
715
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
718
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
720
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceId");
721
status = AXIS2_FAILURE;
725
/* after all, we found this is a empty string */
726
status = adb_ncTerminateInstanceResponseType_set_instanceId(_ncTerminateInstanceResponseType, env,
731
if(AXIS2_FAILURE == status)
733
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceId ");
736
axutil_qname_free(element_qname, env);
738
return AXIS2_FAILURE;
742
else if(!dont_care_minoccurs)
746
axutil_qname_free(element_qname, env);
748
/* this is not a nillable element*/
749
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element instanceId missing");
750
return AXIS2_FAILURE;
755
axutil_qname_free(element_qname, env);
756
element_qname = NULL;
762
* building shutdownState element
768
* because elements are ordered this works fine
772
if(current_node != NULL && is_early_node_valid)
774
current_node = axiom_node_get_next_sibling(current_node, env);
777
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
779
current_node = axiom_node_get_next_sibling(current_node, env);
781
if(current_node != NULL)
783
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
784
qname = axiom_element_get_qname(current_element, env, current_node);
788
is_early_node_valid = AXIS2_FALSE;
790
element_qname = axutil_qname_create(env, "shutdownState", "http://eucalyptus.ucsb.edu/", NULL);
794
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
796
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
798
is_early_node_valid = AXIS2_TRUE;
802
text_value = axiom_element_get_text(current_element, env, current_node);
803
if(text_value != NULL)
805
status = adb_ncTerminateInstanceResponseType_set_shutdownState(_ncTerminateInstanceResponseType, env,
812
* axis2_qname_t *qname = NULL;
813
* axiom_attribute_t *the_attri = NULL;
815
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
816
* the_attri = axiom_element_get_attribute(current_element, env, qname);
818
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
820
axiom_attribute_t *the_attri = NULL;
821
axis2_char_t *attrib_text = NULL;
822
axutil_hash_t *attribute_hash = NULL;
824
attribute_hash = axiom_element_get_all_attributes(current_element, env);
829
axutil_hash_index_t *hi;
833
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
835
axutil_hash_this(hi, &key, NULL, &val);
837
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
839
the_attri = (axiom_attribute_t*)val;
847
attrib_text = axiom_attribute_get_value(the_attri, env);
851
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
852
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
855
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
857
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element shutdownState");
858
status = AXIS2_FAILURE;
862
/* after all, we found this is a empty string */
863
status = adb_ncTerminateInstanceResponseType_set_shutdownState(_ncTerminateInstanceResponseType, env,
868
if(AXIS2_FAILURE == status)
870
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for shutdownState ");
873
axutil_qname_free(element_qname, env);
875
return AXIS2_FAILURE;
881
axutil_qname_free(element_qname, env);
882
element_qname = NULL;
888
* building previousState element
894
* because elements are ordered this works fine
898
if(current_node != NULL && is_early_node_valid)
900
current_node = axiom_node_get_next_sibling(current_node, env);
903
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
905
current_node = axiom_node_get_next_sibling(current_node, env);
907
if(current_node != NULL)
909
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
910
qname = axiom_element_get_qname(current_element, env, current_node);
914
is_early_node_valid = AXIS2_FALSE;
916
element_qname = axutil_qname_create(env, "previousState", "http://eucalyptus.ucsb.edu/", NULL);
920
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
922
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
924
is_early_node_valid = AXIS2_TRUE;
928
text_value = axiom_element_get_text(current_element, env, current_node);
929
if(text_value != NULL)
931
status = adb_ncTerminateInstanceResponseType_set_previousState(_ncTerminateInstanceResponseType, env,
938
* axis2_qname_t *qname = NULL;
939
* axiom_attribute_t *the_attri = NULL;
941
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
942
* the_attri = axiom_element_get_attribute(current_element, env, qname);
944
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
946
axiom_attribute_t *the_attri = NULL;
947
axis2_char_t *attrib_text = NULL;
948
axutil_hash_t *attribute_hash = NULL;
950
attribute_hash = axiom_element_get_all_attributes(current_element, env);
955
axutil_hash_index_t *hi;
959
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
961
axutil_hash_this(hi, &key, NULL, &val);
963
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
965
the_attri = (axiom_attribute_t*)val;
973
attrib_text = axiom_attribute_get_value(the_attri, env);
977
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
978
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
981
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
983
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element previousState");
984
status = AXIS2_FAILURE;
988
/* after all, we found this is a empty string */
989
status = adb_ncTerminateInstanceResponseType_set_previousState(_ncTerminateInstanceResponseType, env,
994
if(AXIS2_FAILURE == status)
996
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for previousState ");
999
axutil_qname_free(element_qname, env);
1001
return AXIS2_FAILURE;
1007
axutil_qname_free(element_qname, env);
1008
element_qname = NULL;
1014
axis2_bool_t AXIS2_CALL
1015
adb_ncTerminateInstanceResponseType_is_particle()
1024
adb_ncTerminateInstanceResponseType_declare_parent_namespaces(
1025
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1026
const axutil_env_t *env, axiom_element_t *parent_element,
1027
axutil_hash_t *namespaces, int *next_ns_index)
1030
/* Here this is an empty function, Nothing to declare */
1036
axiom_node_t* AXIS2_CALL
1037
adb_ncTerminateInstanceResponseType_serialize(
1038
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1039
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)
1043
axis2_char_t *string_to_stream;
1046
axiom_node_t *current_node = NULL;
1051
axiom_namespace_t *ns1 = NULL;
1053
axis2_char_t *qname_uri = NULL;
1054
axis2_char_t *qname_prefix = NULL;
1055
axis2_char_t *p_prefix = NULL;
1056
axis2_bool_t ns_already_defined;
1058
axis2_char_t *text_value_1;
1059
axis2_char_t *text_value_1_temp;
1061
axis2_char_t *text_value_2;
1062
axis2_char_t *text_value_2_temp;
1064
axis2_char_t text_value_3[64];
1066
axis2_char_t *text_value_4;
1067
axis2_char_t *text_value_4_temp;
1069
axis2_char_t text_value_5[64];
1071
axis2_char_t *text_value_6;
1072
axis2_char_t *text_value_6_temp;
1074
axis2_char_t *text_value_7;
1075
axis2_char_t *text_value_7_temp;
1077
axis2_char_t *text_value_8;
1078
axis2_char_t *text_value_8_temp;
1080
axis2_char_t *start_input_str = NULL;
1081
axis2_char_t *end_input_str = NULL;
1082
unsigned int start_input_str_len = 0;
1083
unsigned int end_input_str_len = 0;
1086
axiom_data_source_t *data_source = NULL;
1087
axutil_stream_t *stream = NULL;
1091
AXIS2_ENV_CHECK(env, NULL);
1092
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
1095
current_node = parent;
1096
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1099
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1103
if(!parent_tag_closed)
1106
string_to_stream = ">";
1107
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1112
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1114
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1115
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1116
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1118
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1119
"http://eucalyptus.ucsb.edu/",
1124
if (!_ncTerminateInstanceResponseType->is_valid_correlationId)
1127
/* no need to complain for minoccurs=0 element */
1133
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1134
(4 + axutil_strlen(p_prefix) +
1135
axutil_strlen("correlationId")));
1137
/* axutil_strlen("<:>") + 1 = 4 */
1138
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1139
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1140
/* axutil_strlen("</:>") + 1 = 5 */
1148
* parsing correlationId element
1153
sprintf(start_input_str, "<%s%scorrelationId>",
1154
p_prefix?p_prefix:"",
1155
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1157
start_input_str_len = axutil_strlen(start_input_str);
1158
sprintf(end_input_str, "</%s%scorrelationId>",
1159
p_prefix?p_prefix:"",
1160
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1161
end_input_str_len = axutil_strlen(end_input_str);
1163
text_value_1 = _ncTerminateInstanceResponseType->property_correlationId;
1165
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1168
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1169
if (text_value_1_temp)
1171
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1172
AXIS2_FREE(env->allocator, text_value_1_temp);
1176
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1179
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1182
AXIS2_FREE(env->allocator,start_input_str);
1183
AXIS2_FREE(env->allocator,end_input_str);
1187
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1189
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1190
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1191
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1193
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1194
"http://eucalyptus.ucsb.edu/",
1199
if (!_ncTerminateInstanceResponseType->is_valid_userId)
1202
/* no need to complain for minoccurs=0 element */
1208
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1209
(4 + axutil_strlen(p_prefix) +
1210
axutil_strlen("userId")));
1212
/* axutil_strlen("<:>") + 1 = 4 */
1213
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1214
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1215
/* axutil_strlen("</:>") + 1 = 5 */
1223
* parsing userId element
1228
sprintf(start_input_str, "<%s%suserId>",
1229
p_prefix?p_prefix:"",
1230
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1232
start_input_str_len = axutil_strlen(start_input_str);
1233
sprintf(end_input_str, "</%s%suserId>",
1234
p_prefix?p_prefix:"",
1235
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1236
end_input_str_len = axutil_strlen(end_input_str);
1238
text_value_2 = _ncTerminateInstanceResponseType->property_userId;
1240
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1243
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1244
if (text_value_2_temp)
1246
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1247
AXIS2_FREE(env->allocator, text_value_2_temp);
1251
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1254
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1257
AXIS2_FREE(env->allocator,start_input_str);
1258
AXIS2_FREE(env->allocator,end_input_str);
1262
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1264
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1265
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1266
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1268
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1269
"http://eucalyptus.ucsb.edu/",
1274
if (!_ncTerminateInstanceResponseType->is_valid_return)
1277
/* no need to complain for minoccurs=0 element */
1283
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1284
(4 + axutil_strlen(p_prefix) +
1285
axutil_strlen("return")));
1287
/* axutil_strlen("<:>") + 1 = 4 */
1288
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1289
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1290
/* axutil_strlen("</:>") + 1 = 5 */
1298
* parsing return element
1303
sprintf(start_input_str, "<%s%sreturn>",
1304
p_prefix?p_prefix:"",
1305
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1307
start_input_str_len = axutil_strlen(start_input_str);
1308
sprintf(end_input_str, "</%s%sreturn>",
1309
p_prefix?p_prefix:"",
1310
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1311
end_input_str_len = axutil_strlen(end_input_str);
1313
strcpy(text_value_3, (_ncTerminateInstanceResponseType->property_return)?"true":"false");
1315
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1317
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1319
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1322
AXIS2_FREE(env->allocator,start_input_str);
1323
AXIS2_FREE(env->allocator,end_input_str);
1327
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1329
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1330
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1331
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1333
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1334
"http://eucalyptus.ucsb.edu/",
1339
if (!_ncTerminateInstanceResponseType->is_valid_nodeName)
1342
/* no need to complain for minoccurs=0 element */
1348
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1349
(4 + axutil_strlen(p_prefix) +
1350
axutil_strlen("nodeName")));
1352
/* axutil_strlen("<:>") + 1 = 4 */
1353
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1354
(5 + axutil_strlen(p_prefix) + axutil_strlen("nodeName")));
1355
/* axutil_strlen("</:>") + 1 = 5 */
1363
* parsing nodeName element
1368
sprintf(start_input_str, "<%s%snodeName>",
1369
p_prefix?p_prefix:"",
1370
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1372
start_input_str_len = axutil_strlen(start_input_str);
1373
sprintf(end_input_str, "</%s%snodeName>",
1374
p_prefix?p_prefix:"",
1375
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1376
end_input_str_len = axutil_strlen(end_input_str);
1378
text_value_4 = _ncTerminateInstanceResponseType->property_nodeName;
1380
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1383
text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
1384
if (text_value_4_temp)
1386
axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
1387
AXIS2_FREE(env->allocator, text_value_4_temp);
1391
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1394
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1397
AXIS2_FREE(env->allocator,start_input_str);
1398
AXIS2_FREE(env->allocator,end_input_str);
1402
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1404
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1405
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1406
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1408
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1409
"http://eucalyptus.ucsb.edu/",
1414
if (!_ncTerminateInstanceResponseType->is_valid_statusMessage)
1417
/* no need to complain for minoccurs=0 element */
1423
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1424
(4 + axutil_strlen(p_prefix) +
1425
axutil_strlen("statusMessage")));
1427
/* axutil_strlen("<:>") + 1 = 4 */
1428
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1429
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1430
/* axutil_strlen("</:>") + 1 = 5 */
1438
* parsing statusMessage element
1443
sprintf(start_input_str, "<%s%sstatusMessage>",
1444
p_prefix?p_prefix:"",
1445
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1447
start_input_str_len = axutil_strlen(start_input_str);
1448
sprintf(end_input_str, "</%s%sstatusMessage>",
1449
p_prefix?p_prefix:"",
1450
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1451
end_input_str_len = axutil_strlen(end_input_str);
1453
sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncTerminateInstanceResponseType->property_statusMessage);
1455
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1457
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1459
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1462
AXIS2_FREE(env->allocator,start_input_str);
1463
AXIS2_FREE(env->allocator,end_input_str);
1467
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1469
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1470
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1471
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1473
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1474
"http://eucalyptus.ucsb.edu/",
1479
if (!_ncTerminateInstanceResponseType->is_valid_instanceId)
1483
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property instanceId");
1489
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1490
(4 + axutil_strlen(p_prefix) +
1491
axutil_strlen("instanceId")));
1493
/* axutil_strlen("<:>") + 1 = 4 */
1494
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1495
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceId")));
1496
/* axutil_strlen("</:>") + 1 = 5 */
1504
* parsing instanceId element
1509
sprintf(start_input_str, "<%s%sinstanceId>",
1510
p_prefix?p_prefix:"",
1511
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1513
start_input_str_len = axutil_strlen(start_input_str);
1514
sprintf(end_input_str, "</%s%sinstanceId>",
1515
p_prefix?p_prefix:"",
1516
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1517
end_input_str_len = axutil_strlen(end_input_str);
1519
text_value_6 = _ncTerminateInstanceResponseType->property_instanceId;
1521
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1524
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1525
if (text_value_6_temp)
1527
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1528
AXIS2_FREE(env->allocator, text_value_6_temp);
1532
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1535
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1538
AXIS2_FREE(env->allocator,start_input_str);
1539
AXIS2_FREE(env->allocator,end_input_str);
1543
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1545
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1546
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1547
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1549
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1550
"http://eucalyptus.ucsb.edu/",
1555
if (!_ncTerminateInstanceResponseType->is_valid_shutdownState)
1558
/* no need to complain for minoccurs=0 element */
1564
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1565
(4 + axutil_strlen(p_prefix) +
1566
axutil_strlen("shutdownState")));
1568
/* axutil_strlen("<:>") + 1 = 4 */
1569
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1570
(5 + axutil_strlen(p_prefix) + axutil_strlen("shutdownState")));
1571
/* axutil_strlen("</:>") + 1 = 5 */
1579
* parsing shutdownState element
1584
sprintf(start_input_str, "<%s%sshutdownState>",
1585
p_prefix?p_prefix:"",
1586
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1588
start_input_str_len = axutil_strlen(start_input_str);
1589
sprintf(end_input_str, "</%s%sshutdownState>",
1590
p_prefix?p_prefix:"",
1591
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1592
end_input_str_len = axutil_strlen(end_input_str);
1594
text_value_7 = _ncTerminateInstanceResponseType->property_shutdownState;
1596
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1599
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1600
if (text_value_7_temp)
1602
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
1603
AXIS2_FREE(env->allocator, text_value_7_temp);
1607
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1610
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1613
AXIS2_FREE(env->allocator,start_input_str);
1614
AXIS2_FREE(env->allocator,end_input_str);
1618
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1620
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1621
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1622
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1624
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1625
"http://eucalyptus.ucsb.edu/",
1630
if (!_ncTerminateInstanceResponseType->is_valid_previousState)
1633
/* no need to complain for minoccurs=0 element */
1639
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1640
(4 + axutil_strlen(p_prefix) +
1641
axutil_strlen("previousState")));
1643
/* axutil_strlen("<:>") + 1 = 4 */
1644
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1645
(5 + axutil_strlen(p_prefix) + axutil_strlen("previousState")));
1646
/* axutil_strlen("</:>") + 1 = 5 */
1654
* parsing previousState element
1659
sprintf(start_input_str, "<%s%spreviousState>",
1660
p_prefix?p_prefix:"",
1661
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1663
start_input_str_len = axutil_strlen(start_input_str);
1664
sprintf(end_input_str, "</%s%spreviousState>",
1665
p_prefix?p_prefix:"",
1666
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1667
end_input_str_len = axutil_strlen(end_input_str);
1669
text_value_8 = _ncTerminateInstanceResponseType->property_previousState;
1671
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1674
text_value_8_temp = axutil_xml_quote_string(env, text_value_8, AXIS2_TRUE);
1675
if (text_value_8_temp)
1677
axutil_stream_write(stream, env, text_value_8_temp, axutil_strlen(text_value_8_temp));
1678
AXIS2_FREE(env->allocator, text_value_8_temp);
1682
axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
1685
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1688
AXIS2_FREE(env->allocator,start_input_str);
1689
AXIS2_FREE(env->allocator,end_input_str);
1701
* getter for correlationId.
1703
axis2_char_t* AXIS2_CALL
1704
adb_ncTerminateInstanceResponseType_get_correlationId(
1705
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1706
const axutil_env_t *env)
1709
AXIS2_ENV_CHECK(env, NULL);
1710
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
1713
return _ncTerminateInstanceResponseType->property_correlationId;
1717
* setter for correlationId
1719
axis2_status_t AXIS2_CALL
1720
adb_ncTerminateInstanceResponseType_set_correlationId(
1721
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1722
const axutil_env_t *env,
1723
const axis2_char_t* arg_correlationId)
1727
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1728
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1730
if(_ncTerminateInstanceResponseType->is_valid_correlationId &&
1731
arg_correlationId == _ncTerminateInstanceResponseType->property_correlationId)
1734
return AXIS2_SUCCESS;
1737
adb_ncTerminateInstanceResponseType_reset_correlationId(_ncTerminateInstanceResponseType, env);
1740
if(NULL == arg_correlationId)
1742
/* We are already done */
1743
return AXIS2_SUCCESS;
1745
_ncTerminateInstanceResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1746
if(NULL == _ncTerminateInstanceResponseType->property_correlationId)
1748
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1749
return AXIS2_FAILURE;
1751
_ncTerminateInstanceResponseType->is_valid_correlationId = AXIS2_TRUE;
1753
return AXIS2_SUCCESS;
1759
* resetter for correlationId
1761
axis2_status_t AXIS2_CALL
1762
adb_ncTerminateInstanceResponseType_reset_correlationId(
1763
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1764
const axutil_env_t *env)
1768
void *element = NULL;
1770
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1771
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1777
if(_ncTerminateInstanceResponseType->property_correlationId != NULL)
1781
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_correlationId);
1782
_ncTerminateInstanceResponseType->property_correlationId = NULL;
1787
_ncTerminateInstanceResponseType->is_valid_correlationId = AXIS2_FALSE;
1788
return AXIS2_SUCCESS;
1792
* Check whether correlationId is nill
1794
axis2_bool_t AXIS2_CALL
1795
adb_ncTerminateInstanceResponseType_is_correlationId_nil(
1796
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1797
const axutil_env_t *env)
1799
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1800
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
1802
return !_ncTerminateInstanceResponseType->is_valid_correlationId;
1806
* Set correlationId to nill (currently the same as reset)
1808
axis2_status_t AXIS2_CALL
1809
adb_ncTerminateInstanceResponseType_set_correlationId_nil(
1810
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1811
const axutil_env_t *env)
1813
return adb_ncTerminateInstanceResponseType_reset_correlationId(_ncTerminateInstanceResponseType, env);
1819
* getter for userId.
1821
axis2_char_t* AXIS2_CALL
1822
adb_ncTerminateInstanceResponseType_get_userId(
1823
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1824
const axutil_env_t *env)
1827
AXIS2_ENV_CHECK(env, NULL);
1828
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
1831
return _ncTerminateInstanceResponseType->property_userId;
1837
axis2_status_t AXIS2_CALL
1838
adb_ncTerminateInstanceResponseType_set_userId(
1839
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1840
const axutil_env_t *env,
1841
const axis2_char_t* arg_userId)
1845
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1846
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1848
if(_ncTerminateInstanceResponseType->is_valid_userId &&
1849
arg_userId == _ncTerminateInstanceResponseType->property_userId)
1852
return AXIS2_SUCCESS;
1855
adb_ncTerminateInstanceResponseType_reset_userId(_ncTerminateInstanceResponseType, env);
1858
if(NULL == arg_userId)
1860
/* We are already done */
1861
return AXIS2_SUCCESS;
1863
_ncTerminateInstanceResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1864
if(NULL == _ncTerminateInstanceResponseType->property_userId)
1866
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1867
return AXIS2_FAILURE;
1869
_ncTerminateInstanceResponseType->is_valid_userId = AXIS2_TRUE;
1871
return AXIS2_SUCCESS;
1877
* resetter for userId
1879
axis2_status_t AXIS2_CALL
1880
adb_ncTerminateInstanceResponseType_reset_userId(
1881
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1882
const axutil_env_t *env)
1886
void *element = NULL;
1888
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1889
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1895
if(_ncTerminateInstanceResponseType->property_userId != NULL)
1899
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_userId);
1900
_ncTerminateInstanceResponseType->property_userId = NULL;
1905
_ncTerminateInstanceResponseType->is_valid_userId = AXIS2_FALSE;
1906
return AXIS2_SUCCESS;
1910
* Check whether userId is nill
1912
axis2_bool_t AXIS2_CALL
1913
adb_ncTerminateInstanceResponseType_is_userId_nil(
1914
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1915
const axutil_env_t *env)
1917
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1918
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
1920
return !_ncTerminateInstanceResponseType->is_valid_userId;
1924
* Set userId to nill (currently the same as reset)
1926
axis2_status_t AXIS2_CALL
1927
adb_ncTerminateInstanceResponseType_set_userId_nil(
1928
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1929
const axutil_env_t *env)
1931
return adb_ncTerminateInstanceResponseType_reset_userId(_ncTerminateInstanceResponseType, env);
1937
* getter for return.
1939
axis2_bool_t AXIS2_CALL
1940
adb_ncTerminateInstanceResponseType_get_return(
1941
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1942
const axutil_env_t *env)
1945
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1946
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, (axis2_bool_t)0);
1949
return _ncTerminateInstanceResponseType->property_return;
1955
axis2_status_t AXIS2_CALL
1956
adb_ncTerminateInstanceResponseType_set_return(
1957
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1958
const axutil_env_t *env,
1959
axis2_bool_t arg_return)
1963
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1964
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1966
if(_ncTerminateInstanceResponseType->is_valid_return &&
1967
arg_return == _ncTerminateInstanceResponseType->property_return)
1970
return AXIS2_SUCCESS;
1973
adb_ncTerminateInstanceResponseType_reset_return(_ncTerminateInstanceResponseType, env);
1975
_ncTerminateInstanceResponseType->property_return = arg_return;
1976
_ncTerminateInstanceResponseType->is_valid_return = AXIS2_TRUE;
1978
return AXIS2_SUCCESS;
1984
* resetter for return
1986
axis2_status_t AXIS2_CALL
1987
adb_ncTerminateInstanceResponseType_reset_return(
1988
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
1989
const axutil_env_t *env)
1993
void *element = NULL;
1995
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1996
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
1999
_ncTerminateInstanceResponseType->is_valid_return = AXIS2_FALSE;
2000
return AXIS2_SUCCESS;
2004
* Check whether return is nill
2006
axis2_bool_t AXIS2_CALL
2007
adb_ncTerminateInstanceResponseType_is_return_nil(
2008
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2009
const axutil_env_t *env)
2011
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2012
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2014
return !_ncTerminateInstanceResponseType->is_valid_return;
2018
* Set return to nill (currently the same as reset)
2020
axis2_status_t AXIS2_CALL
2021
adb_ncTerminateInstanceResponseType_set_return_nil(
2022
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2023
const axutil_env_t *env)
2025
return adb_ncTerminateInstanceResponseType_reset_return(_ncTerminateInstanceResponseType, env);
2031
* getter for nodeName.
2033
axis2_char_t* AXIS2_CALL
2034
adb_ncTerminateInstanceResponseType_get_nodeName(
2035
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2036
const axutil_env_t *env)
2039
AXIS2_ENV_CHECK(env, NULL);
2040
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
2043
return _ncTerminateInstanceResponseType->property_nodeName;
2047
* setter for nodeName
2049
axis2_status_t AXIS2_CALL
2050
adb_ncTerminateInstanceResponseType_set_nodeName(
2051
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2052
const axutil_env_t *env,
2053
const axis2_char_t* arg_nodeName)
2057
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2058
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2060
if(_ncTerminateInstanceResponseType->is_valid_nodeName &&
2061
arg_nodeName == _ncTerminateInstanceResponseType->property_nodeName)
2064
return AXIS2_SUCCESS;
2067
adb_ncTerminateInstanceResponseType_reset_nodeName(_ncTerminateInstanceResponseType, env);
2070
if(NULL == arg_nodeName)
2072
/* We are already done */
2073
return AXIS2_SUCCESS;
2075
_ncTerminateInstanceResponseType->property_nodeName = (axis2_char_t *)axutil_strdup(env, arg_nodeName);
2076
if(NULL == _ncTerminateInstanceResponseType->property_nodeName)
2078
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeName");
2079
return AXIS2_FAILURE;
2081
_ncTerminateInstanceResponseType->is_valid_nodeName = AXIS2_TRUE;
2083
return AXIS2_SUCCESS;
2089
* resetter for nodeName
2091
axis2_status_t AXIS2_CALL
2092
adb_ncTerminateInstanceResponseType_reset_nodeName(
2093
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2094
const axutil_env_t *env)
2098
void *element = NULL;
2100
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2101
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2107
if(_ncTerminateInstanceResponseType->property_nodeName != NULL)
2111
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_nodeName);
2112
_ncTerminateInstanceResponseType->property_nodeName = NULL;
2117
_ncTerminateInstanceResponseType->is_valid_nodeName = AXIS2_FALSE;
2118
return AXIS2_SUCCESS;
2122
* Check whether nodeName is nill
2124
axis2_bool_t AXIS2_CALL
2125
adb_ncTerminateInstanceResponseType_is_nodeName_nil(
2126
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2127
const axutil_env_t *env)
2129
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2130
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2132
return !_ncTerminateInstanceResponseType->is_valid_nodeName;
2136
* Set nodeName to nill (currently the same as reset)
2138
axis2_status_t AXIS2_CALL
2139
adb_ncTerminateInstanceResponseType_set_nodeName_nil(
2140
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2141
const axutil_env_t *env)
2143
return adb_ncTerminateInstanceResponseType_reset_nodeName(_ncTerminateInstanceResponseType, env);
2149
* getter for statusMessage.
2152
adb_ncTerminateInstanceResponseType_get_statusMessage(
2153
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2154
const axutil_env_t *env)
2157
AXIS2_ENV_CHECK(env, (int)0);
2158
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, (int)0);
2161
return _ncTerminateInstanceResponseType->property_statusMessage;
2165
* setter for statusMessage
2167
axis2_status_t AXIS2_CALL
2168
adb_ncTerminateInstanceResponseType_set_statusMessage(
2169
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2170
const axutil_env_t *env,
2171
const int arg_statusMessage)
2175
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2176
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2178
if(_ncTerminateInstanceResponseType->is_valid_statusMessage &&
2179
arg_statusMessage == _ncTerminateInstanceResponseType->property_statusMessage)
2182
return AXIS2_SUCCESS;
2185
adb_ncTerminateInstanceResponseType_reset_statusMessage(_ncTerminateInstanceResponseType, env);
2187
_ncTerminateInstanceResponseType->property_statusMessage = arg_statusMessage;
2188
_ncTerminateInstanceResponseType->is_valid_statusMessage = AXIS2_TRUE;
2190
return AXIS2_SUCCESS;
2196
* resetter for statusMessage
2198
axis2_status_t AXIS2_CALL
2199
adb_ncTerminateInstanceResponseType_reset_statusMessage(
2200
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2201
const axutil_env_t *env)
2205
void *element = NULL;
2207
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2208
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2211
_ncTerminateInstanceResponseType->is_valid_statusMessage = AXIS2_FALSE;
2212
return AXIS2_SUCCESS;
2216
* Check whether statusMessage is nill
2218
axis2_bool_t AXIS2_CALL
2219
adb_ncTerminateInstanceResponseType_is_statusMessage_nil(
2220
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2221
const axutil_env_t *env)
2223
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2224
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2226
return !_ncTerminateInstanceResponseType->is_valid_statusMessage;
2230
* Set statusMessage to nill (currently the same as reset)
2232
axis2_status_t AXIS2_CALL
2233
adb_ncTerminateInstanceResponseType_set_statusMessage_nil(
2234
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2235
const axutil_env_t *env)
2237
return adb_ncTerminateInstanceResponseType_reset_statusMessage(_ncTerminateInstanceResponseType, env);
2243
* getter for instanceId.
2245
axis2_char_t* AXIS2_CALL
2246
adb_ncTerminateInstanceResponseType_get_instanceId(
2247
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2248
const axutil_env_t *env)
2251
AXIS2_ENV_CHECK(env, NULL);
2252
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
2255
return _ncTerminateInstanceResponseType->property_instanceId;
2259
* setter for instanceId
2261
axis2_status_t AXIS2_CALL
2262
adb_ncTerminateInstanceResponseType_set_instanceId(
2263
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2264
const axutil_env_t *env,
2265
const axis2_char_t* arg_instanceId)
2269
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2270
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2272
if(_ncTerminateInstanceResponseType->is_valid_instanceId &&
2273
arg_instanceId == _ncTerminateInstanceResponseType->property_instanceId)
2276
return AXIS2_SUCCESS;
2280
if(NULL == arg_instanceId)
2282
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceId is being set to NULL, but it is not a nullable element");
2283
return AXIS2_FAILURE;
2285
adb_ncTerminateInstanceResponseType_reset_instanceId(_ncTerminateInstanceResponseType, env);
2288
if(NULL == arg_instanceId)
2290
/* We are already done */
2291
return AXIS2_SUCCESS;
2293
_ncTerminateInstanceResponseType->property_instanceId = (axis2_char_t *)axutil_strdup(env, arg_instanceId);
2294
if(NULL == _ncTerminateInstanceResponseType->property_instanceId)
2296
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for instanceId");
2297
return AXIS2_FAILURE;
2299
_ncTerminateInstanceResponseType->is_valid_instanceId = AXIS2_TRUE;
2301
return AXIS2_SUCCESS;
2307
* resetter for instanceId
2309
axis2_status_t AXIS2_CALL
2310
adb_ncTerminateInstanceResponseType_reset_instanceId(
2311
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2312
const axutil_env_t *env)
2316
void *element = NULL;
2318
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2319
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2325
if(_ncTerminateInstanceResponseType->property_instanceId != NULL)
2329
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_instanceId);
2330
_ncTerminateInstanceResponseType->property_instanceId = NULL;
2335
_ncTerminateInstanceResponseType->is_valid_instanceId = AXIS2_FALSE;
2336
return AXIS2_SUCCESS;
2340
* Check whether instanceId is nill
2342
axis2_bool_t AXIS2_CALL
2343
adb_ncTerminateInstanceResponseType_is_instanceId_nil(
2344
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2345
const axutil_env_t *env)
2347
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2348
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2350
return !_ncTerminateInstanceResponseType->is_valid_instanceId;
2354
* Set instanceId to nill (currently the same as reset)
2356
axis2_status_t AXIS2_CALL
2357
adb_ncTerminateInstanceResponseType_set_instanceId_nil(
2358
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2359
const axutil_env_t *env)
2361
return adb_ncTerminateInstanceResponseType_reset_instanceId(_ncTerminateInstanceResponseType, env);
2367
* getter for shutdownState.
2369
axis2_char_t* AXIS2_CALL
2370
adb_ncTerminateInstanceResponseType_get_shutdownState(
2371
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2372
const axutil_env_t *env)
2375
AXIS2_ENV_CHECK(env, NULL);
2376
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
2379
return _ncTerminateInstanceResponseType->property_shutdownState;
2383
* setter for shutdownState
2385
axis2_status_t AXIS2_CALL
2386
adb_ncTerminateInstanceResponseType_set_shutdownState(
2387
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2388
const axutil_env_t *env,
2389
const axis2_char_t* arg_shutdownState)
2393
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2394
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2396
if(_ncTerminateInstanceResponseType->is_valid_shutdownState &&
2397
arg_shutdownState == _ncTerminateInstanceResponseType->property_shutdownState)
2400
return AXIS2_SUCCESS;
2403
adb_ncTerminateInstanceResponseType_reset_shutdownState(_ncTerminateInstanceResponseType, env);
2406
if(NULL == arg_shutdownState)
2408
/* We are already done */
2409
return AXIS2_SUCCESS;
2411
_ncTerminateInstanceResponseType->property_shutdownState = (axis2_char_t *)axutil_strdup(env, arg_shutdownState);
2412
if(NULL == _ncTerminateInstanceResponseType->property_shutdownState)
2414
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for shutdownState");
2415
return AXIS2_FAILURE;
2417
_ncTerminateInstanceResponseType->is_valid_shutdownState = AXIS2_TRUE;
2419
return AXIS2_SUCCESS;
2425
* resetter for shutdownState
2427
axis2_status_t AXIS2_CALL
2428
adb_ncTerminateInstanceResponseType_reset_shutdownState(
2429
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2430
const axutil_env_t *env)
2434
void *element = NULL;
2436
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2437
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2443
if(_ncTerminateInstanceResponseType->property_shutdownState != NULL)
2447
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_shutdownState);
2448
_ncTerminateInstanceResponseType->property_shutdownState = NULL;
2453
_ncTerminateInstanceResponseType->is_valid_shutdownState = AXIS2_FALSE;
2454
return AXIS2_SUCCESS;
2458
* Check whether shutdownState is nill
2460
axis2_bool_t AXIS2_CALL
2461
adb_ncTerminateInstanceResponseType_is_shutdownState_nil(
2462
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2463
const axutil_env_t *env)
2465
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2466
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2468
return !_ncTerminateInstanceResponseType->is_valid_shutdownState;
2472
* Set shutdownState to nill (currently the same as reset)
2474
axis2_status_t AXIS2_CALL
2475
adb_ncTerminateInstanceResponseType_set_shutdownState_nil(
2476
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2477
const axutil_env_t *env)
2479
return adb_ncTerminateInstanceResponseType_reset_shutdownState(_ncTerminateInstanceResponseType, env);
2485
* getter for previousState.
2487
axis2_char_t* AXIS2_CALL
2488
adb_ncTerminateInstanceResponseType_get_previousState(
2489
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2490
const axutil_env_t *env)
2493
AXIS2_ENV_CHECK(env, NULL);
2494
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, NULL);
2497
return _ncTerminateInstanceResponseType->property_previousState;
2501
* setter for previousState
2503
axis2_status_t AXIS2_CALL
2504
adb_ncTerminateInstanceResponseType_set_previousState(
2505
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2506
const axutil_env_t *env,
2507
const axis2_char_t* arg_previousState)
2511
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2512
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2514
if(_ncTerminateInstanceResponseType->is_valid_previousState &&
2515
arg_previousState == _ncTerminateInstanceResponseType->property_previousState)
2518
return AXIS2_SUCCESS;
2521
adb_ncTerminateInstanceResponseType_reset_previousState(_ncTerminateInstanceResponseType, env);
2524
if(NULL == arg_previousState)
2526
/* We are already done */
2527
return AXIS2_SUCCESS;
2529
_ncTerminateInstanceResponseType->property_previousState = (axis2_char_t *)axutil_strdup(env, arg_previousState);
2530
if(NULL == _ncTerminateInstanceResponseType->property_previousState)
2532
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for previousState");
2533
return AXIS2_FAILURE;
2535
_ncTerminateInstanceResponseType->is_valid_previousState = AXIS2_TRUE;
2537
return AXIS2_SUCCESS;
2543
* resetter for previousState
2545
axis2_status_t AXIS2_CALL
2546
adb_ncTerminateInstanceResponseType_reset_previousState(
2547
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2548
const axutil_env_t *env)
2552
void *element = NULL;
2554
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2555
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_FAILURE);
2561
if(_ncTerminateInstanceResponseType->property_previousState != NULL)
2565
AXIS2_FREE(env-> allocator, _ncTerminateInstanceResponseType->property_previousState);
2566
_ncTerminateInstanceResponseType->property_previousState = NULL;
2571
_ncTerminateInstanceResponseType->is_valid_previousState = AXIS2_FALSE;
2572
return AXIS2_SUCCESS;
2576
* Check whether previousState is nill
2578
axis2_bool_t AXIS2_CALL
2579
adb_ncTerminateInstanceResponseType_is_previousState_nil(
2580
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2581
const axutil_env_t *env)
2583
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2584
AXIS2_PARAM_CHECK(env->error, _ncTerminateInstanceResponseType, AXIS2_TRUE);
2586
return !_ncTerminateInstanceResponseType->is_valid_previousState;
2590
* Set previousState to nill (currently the same as reset)
2592
axis2_status_t AXIS2_CALL
2593
adb_ncTerminateInstanceResponseType_set_previousState_nil(
2594
adb_ncTerminateInstanceResponseType_t* _ncTerminateInstanceResponseType,
2595
const axutil_env_t *env)
2597
return adb_ncTerminateInstanceResponseType_reset_previousState(_ncTerminateInstanceResponseType, env);
added
removed
node/generated/adb_ncTerminateInstanceResponseType.c
