4
* adb_terminateInstancesType.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_terminateInstancesType.h"
13
* This type was generated from the piece of schema that had
14
* name = terminateInstancesType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_terminateInstancesType
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_char_t* property_statusMessage;
38
axis2_bool_t is_valid_statusMessage;
41
axis2_bool_t property_return;
44
axis2_bool_t is_valid_return;
47
axutil_array_list_t* property_instanceIds;
50
axis2_bool_t is_valid_instanceIds;
57
/************************* Private Function prototypes ********************************/
60
axis2_status_t AXIS2_CALL
61
adb_terminateInstancesType_set_correlationId_nil(
62
adb_terminateInstancesType_t* _terminateInstancesType,
63
const axutil_env_t *env);
66
axis2_status_t AXIS2_CALL
67
adb_terminateInstancesType_set_userId_nil(
68
adb_terminateInstancesType_t* _terminateInstancesType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_terminateInstancesType_set_return_nil(
74
adb_terminateInstancesType_t* _terminateInstancesType,
75
const axutil_env_t *env);
79
/************************* Function Implmentations ********************************/
80
adb_terminateInstancesType_t* AXIS2_CALL
81
adb_terminateInstancesType_create(
82
const axutil_env_t *env)
84
adb_terminateInstancesType_t *_terminateInstancesType = NULL;
86
AXIS2_ENV_CHECK(env, NULL);
88
_terminateInstancesType = (adb_terminateInstancesType_t *) AXIS2_MALLOC(env->
89
allocator, sizeof(adb_terminateInstancesType_t));
91
if(NULL == _terminateInstancesType)
93
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
97
memset(_terminateInstancesType, 0, sizeof(adb_terminateInstancesType_t));
99
_terminateInstancesType->property_correlationId = NULL;
100
_terminateInstancesType->is_valid_correlationId = AXIS2_FALSE;
101
_terminateInstancesType->property_userId = NULL;
102
_terminateInstancesType->is_valid_userId = AXIS2_FALSE;
103
_terminateInstancesType->property_statusMessage = NULL;
104
_terminateInstancesType->is_valid_statusMessage = AXIS2_FALSE;
105
_terminateInstancesType->is_valid_return = AXIS2_FALSE;
106
_terminateInstancesType->property_instanceIds = NULL;
107
_terminateInstancesType->is_valid_instanceIds = AXIS2_FALSE;
110
return _terminateInstancesType;
113
axis2_status_t AXIS2_CALL
114
adb_terminateInstancesType_free (
115
adb_terminateInstancesType_t* _terminateInstancesType,
116
const axutil_env_t *env)
121
void *element = NULL;
124
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
125
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
127
adb_terminateInstancesType_reset_correlationId(_terminateInstancesType, env);
128
adb_terminateInstancesType_reset_userId(_terminateInstancesType, env);
129
adb_terminateInstancesType_reset_statusMessage(_terminateInstancesType, env);
130
adb_terminateInstancesType_reset_return(_terminateInstancesType, env);
131
adb_terminateInstancesType_reset_instanceIds(_terminateInstancesType, env);
134
if(_terminateInstancesType)
136
AXIS2_FREE(env->allocator, _terminateInstancesType);
137
_terminateInstancesType = NULL;
139
return AXIS2_SUCCESS;
145
axis2_status_t AXIS2_CALL
146
adb_terminateInstancesType_deserialize(
147
adb_terminateInstancesType_t* _terminateInstancesType,
148
const axutil_env_t *env,
149
axiom_node_t **dp_parent,
150
axis2_bool_t *dp_is_early_node_valid,
151
axis2_bool_t dont_care_minoccurs)
153
axiom_node_t *parent = *dp_parent;
155
axis2_status_t status = AXIS2_SUCCESS;
157
void *element = NULL;
159
axis2_char_t* text_value = NULL;
160
axutil_qname_t *qname = NULL;
163
axutil_array_list_t *arr_list = NULL;
165
int sequence_broken = 0;
166
axiom_node_t *tmp_node = NULL;
168
axutil_qname_t *element_qname = NULL;
170
axiom_node_t *first_node = NULL;
171
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
172
axiom_node_t *current_node = NULL;
173
axiom_element_t *current_element = NULL;
175
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
176
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
180
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
182
parent = axiom_node_get_next_sibling(parent, env);
186
/* This should be checked before everything */
187
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
188
"Failed in building adb object for terminateInstancesType : "
189
"NULL elemenet can not be passed to deserialize");
190
return AXIS2_FAILURE;
194
first_node = axiom_node_get_first_child(parent, env);
200
* building correlationId element
205
current_node = first_node;
206
is_early_node_valid = AXIS2_FALSE;
209
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
211
current_node = axiom_node_get_next_sibling(current_node, env);
213
if(current_node != NULL)
215
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
216
qname = axiom_element_get_qname(current_element, env, current_node);
219
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
223
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
225
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
227
is_early_node_valid = AXIS2_TRUE;
231
text_value = axiom_element_get_text(current_element, env, current_node);
232
if(text_value != NULL)
234
status = adb_terminateInstancesType_set_correlationId(_terminateInstancesType, env,
241
* axis2_qname_t *qname = NULL;
242
* axiom_attribute_t *the_attri = NULL;
244
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
245
* the_attri = axiom_element_get_attribute(current_element, env, qname);
247
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
249
axiom_attribute_t *the_attri = NULL;
250
axis2_char_t *attrib_text = NULL;
251
axutil_hash_t *attribute_hash = NULL;
253
attribute_hash = axiom_element_get_all_attributes(current_element, env);
258
axutil_hash_index_t *hi;
262
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
264
axutil_hash_this(hi, &key, NULL, &val);
266
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
268
the_attri = (axiom_attribute_t*)val;
276
attrib_text = axiom_attribute_get_value(the_attri, env);
280
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
281
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
284
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
286
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
287
status = AXIS2_FAILURE;
291
/* after all, we found this is a empty string */
292
status = adb_terminateInstancesType_set_correlationId(_terminateInstancesType, env,
297
if(AXIS2_FAILURE == status)
299
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
302
axutil_qname_free(element_qname, env);
304
return AXIS2_FAILURE;
310
axutil_qname_free(element_qname, env);
311
element_qname = NULL;
317
* building userId element
323
* because elements are ordered this works fine
327
if(current_node != NULL && is_early_node_valid)
329
current_node = axiom_node_get_next_sibling(current_node, env);
332
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
334
current_node = axiom_node_get_next_sibling(current_node, env);
336
if(current_node != NULL)
338
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
339
qname = axiom_element_get_qname(current_element, env, current_node);
343
is_early_node_valid = AXIS2_FALSE;
345
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
349
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
351
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
353
is_early_node_valid = AXIS2_TRUE;
357
text_value = axiom_element_get_text(current_element, env, current_node);
358
if(text_value != NULL)
360
status = adb_terminateInstancesType_set_userId(_terminateInstancesType, env,
367
* axis2_qname_t *qname = NULL;
368
* axiom_attribute_t *the_attri = NULL;
370
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
371
* the_attri = axiom_element_get_attribute(current_element, env, qname);
373
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
375
axiom_attribute_t *the_attri = NULL;
376
axis2_char_t *attrib_text = NULL;
377
axutil_hash_t *attribute_hash = NULL;
379
attribute_hash = axiom_element_get_all_attributes(current_element, env);
384
axutil_hash_index_t *hi;
388
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
390
axutil_hash_this(hi, &key, NULL, &val);
392
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
394
the_attri = (axiom_attribute_t*)val;
402
attrib_text = axiom_attribute_get_value(the_attri, env);
406
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
407
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
410
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
412
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
413
status = AXIS2_FAILURE;
417
/* after all, we found this is a empty string */
418
status = adb_terminateInstancesType_set_userId(_terminateInstancesType, env,
423
if(AXIS2_FAILURE == status)
425
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
428
axutil_qname_free(element_qname, env);
430
return AXIS2_FAILURE;
436
axutil_qname_free(element_qname, env);
437
element_qname = NULL;
443
* building statusMessage element
449
* because elements are ordered this works fine
453
if(current_node != NULL && is_early_node_valid)
455
current_node = axiom_node_get_next_sibling(current_node, env);
458
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
460
current_node = axiom_node_get_next_sibling(current_node, env);
462
if(current_node != NULL)
464
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
465
qname = axiom_element_get_qname(current_element, env, current_node);
469
is_early_node_valid = AXIS2_FALSE;
471
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
475
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
477
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
479
is_early_node_valid = AXIS2_TRUE;
483
text_value = axiom_element_get_text(current_element, env, current_node);
484
if(text_value != NULL)
486
status = adb_terminateInstancesType_set_statusMessage(_terminateInstancesType, env,
490
if(AXIS2_FAILURE == status)
492
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
495
axutil_qname_free(element_qname, env);
497
return AXIS2_FAILURE;
503
axutil_qname_free(element_qname, env);
504
element_qname = NULL;
510
* building return element
516
* because elements are ordered this works fine
520
if(current_node != NULL && is_early_node_valid)
522
current_node = axiom_node_get_next_sibling(current_node, env);
525
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
527
current_node = axiom_node_get_next_sibling(current_node, env);
529
if(current_node != NULL)
531
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
532
qname = axiom_element_get_qname(current_element, env, current_node);
536
is_early_node_valid = AXIS2_FALSE;
538
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
542
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
544
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
546
is_early_node_valid = AXIS2_TRUE;
550
text_value = axiom_element_get_text(current_element, env, current_node);
551
if(text_value != NULL)
553
if (!axutil_strcasecmp(text_value , "true"))
555
status = adb_terminateInstancesType_set_return(_terminateInstancesType, env,
560
status = adb_terminateInstancesType_set_return(_terminateInstancesType, env,
567
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
568
status = AXIS2_FAILURE;
571
if(AXIS2_FAILURE == status)
573
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
576
axutil_qname_free(element_qname, env);
578
return AXIS2_FAILURE;
584
axutil_qname_free(element_qname, env);
585
element_qname = NULL;
589
* building instanceIds array
591
arr_list = axutil_array_list_create(env, 10);
596
* building instanceIds element
601
element_qname = axutil_qname_create(env, "instanceIds", "http://eucalyptus.ucsb.edu/", NULL);
604
for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
607
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
609
current_node =axiom_node_get_next_sibling(current_node, env);
610
is_early_node_valid = AXIS2_FALSE;
614
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
615
qname = axiom_element_get_qname(current_element, env, current_node);
617
if (axutil_qname_equals(element_qname, env, qname))
620
is_early_node_valid = AXIS2_TRUE;
623
text_value = axiom_element_get_text(current_element, env, current_node);
624
if(text_value != NULL)
626
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
629
if(AXIS2_FAILURE == status)
631
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceIds ");
634
axutil_qname_free(element_qname, env);
638
axutil_array_list_free(arr_list, env);
640
return AXIS2_FAILURE;
644
current_node = axiom_node_get_next_sibling(current_node, env);
648
is_early_node_valid = AXIS2_FALSE;
657
/* found element out of order */
658
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceIds (@minOccurs = '0') only have %d elements", i);
661
axutil_qname_free(element_qname, env);
665
axutil_array_list_free(arr_list, env);
667
return AXIS2_FAILURE;
671
if(0 == axutil_array_list_size(arr_list,env))
673
axutil_array_list_free(arr_list, env);
677
status = adb_terminateInstancesType_set_instanceIds(_terminateInstancesType, env,
684
axutil_qname_free(element_qname, env);
685
element_qname = NULL;
691
axis2_bool_t AXIS2_CALL
692
adb_terminateInstancesType_is_particle()
701
adb_terminateInstancesType_declare_parent_namespaces(
702
adb_terminateInstancesType_t* _terminateInstancesType,
703
const axutil_env_t *env, axiom_element_t *parent_element,
704
axutil_hash_t *namespaces, int *next_ns_index)
707
/* Here this is an empty function, Nothing to declare */
713
axiom_node_t* AXIS2_CALL
714
adb_terminateInstancesType_serialize(
715
adb_terminateInstancesType_t* _terminateInstancesType,
716
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)
720
axis2_char_t *string_to_stream;
723
axiom_node_t *current_node = NULL;
728
axiom_namespace_t *ns1 = NULL;
730
axis2_char_t *qname_uri = NULL;
731
axis2_char_t *qname_prefix = NULL;
732
axis2_char_t *p_prefix = NULL;
733
axis2_bool_t ns_already_defined;
737
void *element = NULL;
739
axis2_char_t *text_value_1;
740
axis2_char_t *text_value_1_temp;
742
axis2_char_t *text_value_2;
743
axis2_char_t *text_value_2_temp;
745
axis2_char_t *text_value_3;
746
axis2_char_t *text_value_3_temp;
748
axis2_char_t text_value_4[64];
750
axis2_char_t *text_value_5;
751
axis2_char_t *text_value_5_temp;
753
axis2_char_t *start_input_str = NULL;
754
axis2_char_t *end_input_str = NULL;
755
unsigned int start_input_str_len = 0;
756
unsigned int end_input_str_len = 0;
759
axiom_data_source_t *data_source = NULL;
760
axutil_stream_t *stream = NULL;
764
AXIS2_ENV_CHECK(env, NULL);
765
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, NULL);
768
current_node = parent;
769
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
772
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
776
if(!parent_tag_closed)
779
string_to_stream = ">";
780
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
785
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
787
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
788
sprintf(p_prefix, "n%d", (*next_ns_index)++);
789
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
791
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
792
"http://eucalyptus.ucsb.edu/",
797
if (!_terminateInstancesType->is_valid_correlationId)
800
/* no need to complain for minoccurs=0 element */
806
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
807
(4 + axutil_strlen(p_prefix) +
808
axutil_strlen("correlationId")));
810
/* axutil_strlen("<:>") + 1 = 4 */
811
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
812
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
813
/* axutil_strlen("</:>") + 1 = 5 */
821
* parsing correlationId element
826
sprintf(start_input_str, "<%s%scorrelationId>",
827
p_prefix?p_prefix:"",
828
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
830
start_input_str_len = axutil_strlen(start_input_str);
831
sprintf(end_input_str, "</%s%scorrelationId>",
832
p_prefix?p_prefix:"",
833
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
834
end_input_str_len = axutil_strlen(end_input_str);
836
text_value_1 = _terminateInstancesType->property_correlationId;
838
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
841
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
842
if (text_value_1_temp)
844
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
845
AXIS2_FREE(env->allocator, text_value_1_temp);
849
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
852
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
855
AXIS2_FREE(env->allocator,start_input_str);
856
AXIS2_FREE(env->allocator,end_input_str);
860
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
862
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
863
sprintf(p_prefix, "n%d", (*next_ns_index)++);
864
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
866
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
867
"http://eucalyptus.ucsb.edu/",
872
if (!_terminateInstancesType->is_valid_userId)
875
/* no need to complain for minoccurs=0 element */
881
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
882
(4 + axutil_strlen(p_prefix) +
883
axutil_strlen("userId")));
885
/* axutil_strlen("<:>") + 1 = 4 */
886
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
887
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
888
/* axutil_strlen("</:>") + 1 = 5 */
896
* parsing userId element
901
sprintf(start_input_str, "<%s%suserId>",
902
p_prefix?p_prefix:"",
903
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
905
start_input_str_len = axutil_strlen(start_input_str);
906
sprintf(end_input_str, "</%s%suserId>",
907
p_prefix?p_prefix:"",
908
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
909
end_input_str_len = axutil_strlen(end_input_str);
911
text_value_2 = _terminateInstancesType->property_userId;
913
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
916
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
917
if (text_value_2_temp)
919
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
920
AXIS2_FREE(env->allocator, text_value_2_temp);
924
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
927
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
930
AXIS2_FREE(env->allocator,start_input_str);
931
AXIS2_FREE(env->allocator,end_input_str);
935
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
937
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
938
sprintf(p_prefix, "n%d", (*next_ns_index)++);
939
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
941
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
942
"http://eucalyptus.ucsb.edu/",
947
if (!_terminateInstancesType->is_valid_statusMessage)
950
/* no need to complain for minoccurs=0 element */
956
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
957
(4 + axutil_strlen(p_prefix) +
958
axutil_strlen("statusMessage")));
960
/* axutil_strlen("<:>") + 1 = 4 */
961
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
962
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
963
/* axutil_strlen("</:>") + 1 = 5 */
971
* parsing statusMessage element
976
sprintf(start_input_str, "<%s%sstatusMessage>",
977
p_prefix?p_prefix:"",
978
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
980
start_input_str_len = axutil_strlen(start_input_str);
981
sprintf(end_input_str, "</%s%sstatusMessage>",
982
p_prefix?p_prefix:"",
983
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
984
end_input_str_len = axutil_strlen(end_input_str);
986
text_value_3 = _terminateInstancesType->property_statusMessage;
988
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
991
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
992
if (text_value_3_temp)
994
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
995
AXIS2_FREE(env->allocator, text_value_3_temp);
999
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1002
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1005
AXIS2_FREE(env->allocator,start_input_str);
1006
AXIS2_FREE(env->allocator,end_input_str);
1010
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1012
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1013
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1014
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1016
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1017
"http://eucalyptus.ucsb.edu/",
1022
if (!_terminateInstancesType->is_valid_return)
1025
/* no need to complain for minoccurs=0 element */
1031
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1032
(4 + axutil_strlen(p_prefix) +
1033
axutil_strlen("return")));
1035
/* axutil_strlen("<:>") + 1 = 4 */
1036
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1037
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1038
/* axutil_strlen("</:>") + 1 = 5 */
1046
* parsing return element
1051
sprintf(start_input_str, "<%s%sreturn>",
1052
p_prefix?p_prefix:"",
1053
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1055
start_input_str_len = axutil_strlen(start_input_str);
1056
sprintf(end_input_str, "</%s%sreturn>",
1057
p_prefix?p_prefix:"",
1058
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1059
end_input_str_len = axutil_strlen(end_input_str);
1061
strcpy(text_value_4, (_terminateInstancesType->property_return)?"true":"false");
1063
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1065
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1067
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1070
AXIS2_FREE(env->allocator,start_input_str);
1071
AXIS2_FREE(env->allocator,end_input_str);
1075
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1077
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1078
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1079
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1081
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1082
"http://eucalyptus.ucsb.edu/",
1087
if (!_terminateInstancesType->is_valid_instanceIds)
1090
/* no need to complain for minoccurs=0 element */
1096
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1097
(4 + axutil_strlen(p_prefix) +
1098
axutil_strlen("instanceIds")));
1100
/* axutil_strlen("<:>") + 1 = 4 */
1101
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1102
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceIds")));
1103
/* axutil_strlen("</:>") + 1 = 5 */
1110
* Parsing instanceIds array
1112
if (_terminateInstancesType->property_instanceIds != NULL)
1115
sprintf(start_input_str, "<%s%sinstanceIds>",
1116
p_prefix?p_prefix:"",
1117
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1119
start_input_str_len = axutil_strlen(start_input_str);
1121
sprintf(end_input_str, "</%s%sinstanceIds>",
1122
p_prefix?p_prefix:"",
1123
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1124
end_input_str_len = axutil_strlen(end_input_str);
1126
count = axutil_array_list_size(_terminateInstancesType->property_instanceIds, env);
1127
for(i = 0; i < count; i ++)
1129
element = axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i);
1138
* parsing instanceIds element
1143
text_value_5 = (axis2_char_t*)element;
1145
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1148
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1149
if (text_value_5_temp)
1151
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1152
AXIS2_FREE(env->allocator, text_value_5_temp);
1156
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1159
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1165
AXIS2_FREE(env->allocator,start_input_str);
1166
AXIS2_FREE(env->allocator,end_input_str);
1178
* getter for correlationId.
1180
axis2_char_t* AXIS2_CALL
1181
adb_terminateInstancesType_get_correlationId(
1182
adb_terminateInstancesType_t* _terminateInstancesType,
1183
const axutil_env_t *env)
1186
AXIS2_ENV_CHECK(env, NULL);
1187
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, NULL);
1190
return _terminateInstancesType->property_correlationId;
1194
* setter for correlationId
1196
axis2_status_t AXIS2_CALL
1197
adb_terminateInstancesType_set_correlationId(
1198
adb_terminateInstancesType_t* _terminateInstancesType,
1199
const axutil_env_t *env,
1200
const axis2_char_t* arg_correlationId)
1204
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1205
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1207
if(_terminateInstancesType->is_valid_correlationId &&
1208
arg_correlationId == _terminateInstancesType->property_correlationId)
1211
return AXIS2_SUCCESS;
1214
adb_terminateInstancesType_reset_correlationId(_terminateInstancesType, env);
1217
if(NULL == arg_correlationId)
1219
/* We are already done */
1220
return AXIS2_SUCCESS;
1222
_terminateInstancesType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1223
if(NULL == _terminateInstancesType->property_correlationId)
1225
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1226
return AXIS2_FAILURE;
1228
_terminateInstancesType->is_valid_correlationId = AXIS2_TRUE;
1230
return AXIS2_SUCCESS;
1236
* resetter for correlationId
1238
axis2_status_t AXIS2_CALL
1239
adb_terminateInstancesType_reset_correlationId(
1240
adb_terminateInstancesType_t* _terminateInstancesType,
1241
const axutil_env_t *env)
1245
void *element = NULL;
1247
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1248
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1254
if(_terminateInstancesType->property_correlationId != NULL)
1258
AXIS2_FREE(env-> allocator, _terminateInstancesType->property_correlationId);
1259
_terminateInstancesType->property_correlationId = NULL;
1264
_terminateInstancesType->is_valid_correlationId = AXIS2_FALSE;
1265
return AXIS2_SUCCESS;
1269
* Check whether correlationId is nill
1271
axis2_bool_t AXIS2_CALL
1272
adb_terminateInstancesType_is_correlationId_nil(
1273
adb_terminateInstancesType_t* _terminateInstancesType,
1274
const axutil_env_t *env)
1276
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1277
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_TRUE);
1279
return !_terminateInstancesType->is_valid_correlationId;
1283
* Set correlationId to nill (currently the same as reset)
1285
axis2_status_t AXIS2_CALL
1286
adb_terminateInstancesType_set_correlationId_nil(
1287
adb_terminateInstancesType_t* _terminateInstancesType,
1288
const axutil_env_t *env)
1290
return adb_terminateInstancesType_reset_correlationId(_terminateInstancesType, env);
1296
* getter for userId.
1298
axis2_char_t* AXIS2_CALL
1299
adb_terminateInstancesType_get_userId(
1300
adb_terminateInstancesType_t* _terminateInstancesType,
1301
const axutil_env_t *env)
1304
AXIS2_ENV_CHECK(env, NULL);
1305
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, NULL);
1308
return _terminateInstancesType->property_userId;
1314
axis2_status_t AXIS2_CALL
1315
adb_terminateInstancesType_set_userId(
1316
adb_terminateInstancesType_t* _terminateInstancesType,
1317
const axutil_env_t *env,
1318
const axis2_char_t* arg_userId)
1322
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1323
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1325
if(_terminateInstancesType->is_valid_userId &&
1326
arg_userId == _terminateInstancesType->property_userId)
1329
return AXIS2_SUCCESS;
1332
adb_terminateInstancesType_reset_userId(_terminateInstancesType, env);
1335
if(NULL == arg_userId)
1337
/* We are already done */
1338
return AXIS2_SUCCESS;
1340
_terminateInstancesType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1341
if(NULL == _terminateInstancesType->property_userId)
1343
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1344
return AXIS2_FAILURE;
1346
_terminateInstancesType->is_valid_userId = AXIS2_TRUE;
1348
return AXIS2_SUCCESS;
1354
* resetter for userId
1356
axis2_status_t AXIS2_CALL
1357
adb_terminateInstancesType_reset_userId(
1358
adb_terminateInstancesType_t* _terminateInstancesType,
1359
const axutil_env_t *env)
1363
void *element = NULL;
1365
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1366
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1372
if(_terminateInstancesType->property_userId != NULL)
1376
AXIS2_FREE(env-> allocator, _terminateInstancesType->property_userId);
1377
_terminateInstancesType->property_userId = NULL;
1382
_terminateInstancesType->is_valid_userId = AXIS2_FALSE;
1383
return AXIS2_SUCCESS;
1387
* Check whether userId is nill
1389
axis2_bool_t AXIS2_CALL
1390
adb_terminateInstancesType_is_userId_nil(
1391
adb_terminateInstancesType_t* _terminateInstancesType,
1392
const axutil_env_t *env)
1394
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1395
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_TRUE);
1397
return !_terminateInstancesType->is_valid_userId;
1401
* Set userId to nill (currently the same as reset)
1403
axis2_status_t AXIS2_CALL
1404
adb_terminateInstancesType_set_userId_nil(
1405
adb_terminateInstancesType_t* _terminateInstancesType,
1406
const axutil_env_t *env)
1408
return adb_terminateInstancesType_reset_userId(_terminateInstancesType, env);
1414
* getter for statusMessage.
1416
axis2_char_t* AXIS2_CALL
1417
adb_terminateInstancesType_get_statusMessage(
1418
adb_terminateInstancesType_t* _terminateInstancesType,
1419
const axutil_env_t *env)
1422
AXIS2_ENV_CHECK(env, NULL);
1423
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, NULL);
1426
return _terminateInstancesType->property_statusMessage;
1430
* setter for statusMessage
1432
axis2_status_t AXIS2_CALL
1433
adb_terminateInstancesType_set_statusMessage(
1434
adb_terminateInstancesType_t* _terminateInstancesType,
1435
const axutil_env_t *env,
1436
const axis2_char_t* arg_statusMessage)
1440
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1441
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1443
if(_terminateInstancesType->is_valid_statusMessage &&
1444
arg_statusMessage == _terminateInstancesType->property_statusMessage)
1447
return AXIS2_SUCCESS;
1450
adb_terminateInstancesType_reset_statusMessage(_terminateInstancesType, env);
1453
if(NULL == arg_statusMessage)
1455
/* We are already done */
1456
return AXIS2_SUCCESS;
1458
_terminateInstancesType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1459
if(NULL == _terminateInstancesType->property_statusMessage)
1461
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1462
return AXIS2_FAILURE;
1464
_terminateInstancesType->is_valid_statusMessage = AXIS2_TRUE;
1466
return AXIS2_SUCCESS;
1472
* resetter for statusMessage
1474
axis2_status_t AXIS2_CALL
1475
adb_terminateInstancesType_reset_statusMessage(
1476
adb_terminateInstancesType_t* _terminateInstancesType,
1477
const axutil_env_t *env)
1481
void *element = NULL;
1483
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1484
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1490
if(_terminateInstancesType->property_statusMessage != NULL)
1494
AXIS2_FREE(env-> allocator, _terminateInstancesType->property_statusMessage);
1495
_terminateInstancesType->property_statusMessage = NULL;
1500
_terminateInstancesType->is_valid_statusMessage = AXIS2_FALSE;
1501
return AXIS2_SUCCESS;
1505
* Check whether statusMessage is nill
1507
axis2_bool_t AXIS2_CALL
1508
adb_terminateInstancesType_is_statusMessage_nil(
1509
adb_terminateInstancesType_t* _terminateInstancesType,
1510
const axutil_env_t *env)
1512
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1513
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_TRUE);
1515
return !_terminateInstancesType->is_valid_statusMessage;
1519
* Set statusMessage to nill (currently the same as reset)
1521
axis2_status_t AXIS2_CALL
1522
adb_terminateInstancesType_set_statusMessage_nil(
1523
adb_terminateInstancesType_t* _terminateInstancesType,
1524
const axutil_env_t *env)
1526
return adb_terminateInstancesType_reset_statusMessage(_terminateInstancesType, env);
1532
* getter for return.
1534
axis2_bool_t AXIS2_CALL
1535
adb_terminateInstancesType_get_return(
1536
adb_terminateInstancesType_t* _terminateInstancesType,
1537
const axutil_env_t *env)
1540
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1541
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, (axis2_bool_t)0);
1544
return _terminateInstancesType->property_return;
1550
axis2_status_t AXIS2_CALL
1551
adb_terminateInstancesType_set_return(
1552
adb_terminateInstancesType_t* _terminateInstancesType,
1553
const axutil_env_t *env,
1554
axis2_bool_t arg_return)
1558
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1559
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1561
if(_terminateInstancesType->is_valid_return &&
1562
arg_return == _terminateInstancesType->property_return)
1565
return AXIS2_SUCCESS;
1568
adb_terminateInstancesType_reset_return(_terminateInstancesType, env);
1570
_terminateInstancesType->property_return = arg_return;
1571
_terminateInstancesType->is_valid_return = AXIS2_TRUE;
1573
return AXIS2_SUCCESS;
1579
* resetter for return
1581
axis2_status_t AXIS2_CALL
1582
adb_terminateInstancesType_reset_return(
1583
adb_terminateInstancesType_t* _terminateInstancesType,
1584
const axutil_env_t *env)
1588
void *element = NULL;
1590
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1591
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1594
_terminateInstancesType->is_valid_return = AXIS2_FALSE;
1595
return AXIS2_SUCCESS;
1599
* Check whether return is nill
1601
axis2_bool_t AXIS2_CALL
1602
adb_terminateInstancesType_is_return_nil(
1603
adb_terminateInstancesType_t* _terminateInstancesType,
1604
const axutil_env_t *env)
1606
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1607
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_TRUE);
1609
return !_terminateInstancesType->is_valid_return;
1613
* Set return to nill (currently the same as reset)
1615
axis2_status_t AXIS2_CALL
1616
adb_terminateInstancesType_set_return_nil(
1617
adb_terminateInstancesType_t* _terminateInstancesType,
1618
const axutil_env_t *env)
1620
return adb_terminateInstancesType_reset_return(_terminateInstancesType, env);
1626
* getter for instanceIds.
1628
axutil_array_list_t* AXIS2_CALL
1629
adb_terminateInstancesType_get_instanceIds(
1630
adb_terminateInstancesType_t* _terminateInstancesType,
1631
const axutil_env_t *env)
1634
AXIS2_ENV_CHECK(env, NULL);
1635
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, NULL);
1638
return _terminateInstancesType->property_instanceIds;
1642
* setter for instanceIds
1644
axis2_status_t AXIS2_CALL
1645
adb_terminateInstancesType_set_instanceIds(
1646
adb_terminateInstancesType_t* _terminateInstancesType,
1647
const axutil_env_t *env,
1648
axutil_array_list_t* arg_instanceIds)
1653
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1656
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1657
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1659
if(_terminateInstancesType->is_valid_instanceIds &&
1660
arg_instanceIds == _terminateInstancesType->property_instanceIds)
1663
return AXIS2_SUCCESS;
1667
size = axutil_array_list_size(arg_instanceIds, env);
1671
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceIds has less than minOccurs(0)");
1672
return AXIS2_FAILURE;
1674
for(i = 0; i < size; i ++ )
1676
if(NULL != axutil_array_list_get(arg_instanceIds, env, i))
1678
non_nil_exists = AXIS2_TRUE;
1683
adb_terminateInstancesType_reset_instanceIds(_terminateInstancesType, env);
1686
if(NULL == arg_instanceIds)
1688
/* We are already done */
1689
return AXIS2_SUCCESS;
1691
_terminateInstancesType->property_instanceIds = arg_instanceIds;
1694
_terminateInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1698
return AXIS2_SUCCESS;
1703
* Get ith element of instanceIds.
1705
axis2_char_t* AXIS2_CALL
1706
adb_terminateInstancesType_get_instanceIds_at(
1707
adb_terminateInstancesType_t* _terminateInstancesType,
1708
const axutil_env_t *env, int i)
1710
axis2_char_t* ret_val;
1713
AXIS2_ENV_CHECK(env, NULL);
1714
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, NULL);
1717
if(_terminateInstancesType->property_instanceIds == NULL)
1719
return (axis2_char_t*)0;
1721
ret_val = (axis2_char_t*)axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i);
1728
* Set the ith element of instanceIds.
1730
axis2_status_t AXIS2_CALL
1731
adb_terminateInstancesType_set_instanceIds_at(
1732
adb_terminateInstancesType_t* _terminateInstancesType,
1733
const axutil_env_t *env, int i,
1734
const axis2_char_t* arg_instanceIds)
1736
void *element = NULL;
1740
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1744
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1745
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1747
if( _terminateInstancesType->is_valid_instanceIds &&
1748
_terminateInstancesType->property_instanceIds &&
1750
arg_instanceIds == (axis2_char_t*)axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i))
1754
return AXIS2_SUCCESS;
1758
if(NULL == arg_instanceIds)
1760
if(_terminateInstancesType->property_instanceIds != NULL)
1762
size = axutil_array_list_size(_terminateInstancesType->property_instanceIds, env);
1763
for(j = 0, k = 0; j < size; j ++ )
1765
if(i == j) continue;
1766
if(NULL != axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i))
1769
non_nil_exists = AXIS2_TRUE;
1780
non_nil_exists = AXIS2_TRUE;
1785
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of instanceIds is beinng set to be smaller than the specificed number of minOccurs(0)");
1786
return AXIS2_FAILURE;
1789
if(_terminateInstancesType->property_instanceIds == NULL)
1791
_terminateInstancesType->property_instanceIds = axutil_array_list_create(env, 10);
1794
/* check whether there already exist an element */
1795
element = axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i);
1801
/* This is an unknown type or a primitive. Please free this manually*/
1809
_terminateInstancesType->is_valid_instanceIds = AXIS2_FALSE;
1810
axutil_array_list_set(_terminateInstancesType->property_instanceIds , env, i, NULL);
1812
return AXIS2_SUCCESS;
1815
axutil_array_list_set(_terminateInstancesType->property_instanceIds , env, i, axutil_strdup(env, arg_instanceIds));
1816
_terminateInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1818
return AXIS2_SUCCESS;
1822
* Add to instanceIds.
1824
axis2_status_t AXIS2_CALL
1825
adb_terminateInstancesType_add_instanceIds(
1826
adb_terminateInstancesType_t* _terminateInstancesType,
1827
const axutil_env_t *env,
1828
const axis2_char_t* arg_instanceIds)
1832
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1833
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1836
if(NULL == arg_instanceIds)
1839
return AXIS2_SUCCESS;
1844
if(_terminateInstancesType->property_instanceIds == NULL)
1846
_terminateInstancesType->property_instanceIds = axutil_array_list_create(env, 10);
1848
if(_terminateInstancesType->property_instanceIds == NULL)
1850
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for instanceIds");
1851
return AXIS2_FAILURE;
1855
axutil_array_list_add(_terminateInstancesType->property_instanceIds , env, axutil_strdup(env, arg_instanceIds));
1856
_terminateInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1857
return AXIS2_SUCCESS;
1861
* Get the size of the instanceIds array.
1864
adb_terminateInstancesType_sizeof_instanceIds(
1865
adb_terminateInstancesType_t* _terminateInstancesType,
1866
const axutil_env_t *env)
1868
AXIS2_ENV_CHECK(env, -1);
1869
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, -1);
1870
if(_terminateInstancesType->property_instanceIds == NULL)
1874
return axutil_array_list_size(_terminateInstancesType->property_instanceIds, env);
1878
* remove the ith element, same as set_nil_at.
1880
axis2_status_t AXIS2_CALL
1881
adb_terminateInstancesType_remove_instanceIds_at(
1882
adb_terminateInstancesType_t* _terminateInstancesType,
1883
const axutil_env_t *env, int i)
1885
return adb_terminateInstancesType_set_instanceIds_nil_at(_terminateInstancesType, env, i);
1891
* resetter for instanceIds
1893
axis2_status_t AXIS2_CALL
1894
adb_terminateInstancesType_reset_instanceIds(
1895
adb_terminateInstancesType_t* _terminateInstancesType,
1896
const axutil_env_t *env)
1900
void *element = NULL;
1902
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1903
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1907
if (_terminateInstancesType->property_instanceIds != NULL)
1909
count = axutil_array_list_size(_terminateInstancesType->property_instanceIds, env);
1910
for(i = 0; i < count; i ++)
1912
element = axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i);
1920
AXIS2_FREE(env-> allocator, (axis2_char_t*)element);
1928
axutil_array_list_free(_terminateInstancesType->property_instanceIds, env);
1930
_terminateInstancesType->is_valid_instanceIds = AXIS2_FALSE;
1931
return AXIS2_SUCCESS;
1935
* Check whether instanceIds is nill
1937
axis2_bool_t AXIS2_CALL
1938
adb_terminateInstancesType_is_instanceIds_nil(
1939
adb_terminateInstancesType_t* _terminateInstancesType,
1940
const axutil_env_t *env)
1942
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1943
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_TRUE);
1945
return !_terminateInstancesType->is_valid_instanceIds;
1949
* Set instanceIds to nill (currently the same as reset)
1951
axis2_status_t AXIS2_CALL
1952
adb_terminateInstancesType_set_instanceIds_nil(
1953
adb_terminateInstancesType_t* _terminateInstancesType,
1954
const axutil_env_t *env)
1956
return adb_terminateInstancesType_reset_instanceIds(_terminateInstancesType, env);
1961
* Check whether instanceIds is nill at i
1963
axis2_bool_t AXIS2_CALL
1964
adb_terminateInstancesType_is_instanceIds_nil_at(
1965
adb_terminateInstancesType_t* _terminateInstancesType,
1966
const axutil_env_t *env, int i)
1968
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1969
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_TRUE);
1971
return (_terminateInstancesType->is_valid_instanceIds == AXIS2_FALSE ||
1972
NULL == _terminateInstancesType->property_instanceIds ||
1973
NULL == axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i));
1977
* Set instanceIds to nill at i
1979
axis2_status_t AXIS2_CALL
1980
adb_terminateInstancesType_set_instanceIds_nil_at(
1981
adb_terminateInstancesType_t* _terminateInstancesType,
1982
const axutil_env_t *env, int i)
1984
void *element = NULL;
1987
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1991
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1992
AXIS2_PARAM_CHECK(env->error, _terminateInstancesType, AXIS2_FAILURE);
1994
if(_terminateInstancesType->property_instanceIds == NULL ||
1995
_terminateInstancesType->is_valid_instanceIds == AXIS2_FALSE)
1998
non_nil_exists = AXIS2_FALSE;
2002
size = axutil_array_list_size(_terminateInstancesType->property_instanceIds, env);
2003
for(j = 0, k = 0; j < size; j ++ )
2005
if(i == j) continue;
2006
if(NULL != axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i))
2009
non_nil_exists = AXIS2_TRUE;
2021
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of instanceIds is beinng set to be smaller than the specificed number of minOccurs(0)");
2022
return AXIS2_FAILURE;
2025
if(_terminateInstancesType->property_instanceIds == NULL)
2027
_terminateInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2029
return AXIS2_SUCCESS;
2032
/* check whether there already exist an element */
2033
element = axutil_array_list_get(_terminateInstancesType->property_instanceIds, env, i);
2039
/* This is an unknown type or a primitive. Please free this manually*/
2047
_terminateInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2048
axutil_array_list_set(_terminateInstancesType->property_instanceIds , env, i, NULL);
2049
return AXIS2_SUCCESS;
2054
axutil_array_list_set(_terminateInstancesType->property_instanceIds , env, i, NULL);
2056
return AXIS2_SUCCESS;
added
removed
cluster/generated/adb_terminateInstancesType.c
