4
* adb_rebootInstancesType.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_rebootInstancesType.h"
13
* This type was generated from the piece of schema that had
14
* name = rebootInstancesType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_rebootInstancesType
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_rebootInstancesType_set_correlationId_nil(
62
adb_rebootInstancesType_t* _rebootInstancesType,
63
const axutil_env_t *env);
66
axis2_status_t AXIS2_CALL
67
adb_rebootInstancesType_set_userId_nil(
68
adb_rebootInstancesType_t* _rebootInstancesType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_rebootInstancesType_set_return_nil(
74
adb_rebootInstancesType_t* _rebootInstancesType,
75
const axutil_env_t *env);
77
axis2_status_t AXIS2_CALL
78
adb_rebootInstancesType_set_instanceIds_nil_at(
79
adb_rebootInstancesType_t* _rebootInstancesType,
80
const axutil_env_t *env, int i);
83
axis2_status_t AXIS2_CALL
84
adb_rebootInstancesType_set_instanceIds_nil(
85
adb_rebootInstancesType_t* _rebootInstancesType,
86
const axutil_env_t *env);
90
/************************* Function Implmentations ********************************/
91
adb_rebootInstancesType_t* AXIS2_CALL
92
adb_rebootInstancesType_create(
93
const axutil_env_t *env)
95
adb_rebootInstancesType_t *_rebootInstancesType = NULL;
97
AXIS2_ENV_CHECK(env, NULL);
99
_rebootInstancesType = (adb_rebootInstancesType_t *) AXIS2_MALLOC(env->
100
allocator, sizeof(adb_rebootInstancesType_t));
102
if(NULL == _rebootInstancesType)
104
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
108
memset(_rebootInstancesType, 0, sizeof(adb_rebootInstancesType_t));
110
_rebootInstancesType->property_correlationId = NULL;
111
_rebootInstancesType->is_valid_correlationId = AXIS2_FALSE;
112
_rebootInstancesType->property_userId = NULL;
113
_rebootInstancesType->is_valid_userId = AXIS2_FALSE;
114
_rebootInstancesType->property_statusMessage = NULL;
115
_rebootInstancesType->is_valid_statusMessage = AXIS2_FALSE;
116
_rebootInstancesType->is_valid_return = AXIS2_FALSE;
117
_rebootInstancesType->property_instanceIds = NULL;
118
_rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
121
return _rebootInstancesType;
124
axis2_status_t AXIS2_CALL
125
adb_rebootInstancesType_free (
126
adb_rebootInstancesType_t* _rebootInstancesType,
127
const axutil_env_t *env)
132
void *element = NULL;
135
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
136
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
138
adb_rebootInstancesType_reset_correlationId(_rebootInstancesType, env);
139
adb_rebootInstancesType_reset_userId(_rebootInstancesType, env);
140
adb_rebootInstancesType_reset_statusMessage(_rebootInstancesType, env);
141
adb_rebootInstancesType_reset_return(_rebootInstancesType, env);
142
adb_rebootInstancesType_reset_instanceIds(_rebootInstancesType, env);
145
if(_rebootInstancesType)
147
AXIS2_FREE(env->allocator, _rebootInstancesType);
148
_rebootInstancesType = NULL;
150
return AXIS2_SUCCESS;
156
axis2_status_t AXIS2_CALL
157
adb_rebootInstancesType_deserialize(
158
adb_rebootInstancesType_t* _rebootInstancesType,
159
const axutil_env_t *env,
160
axiom_node_t **dp_parent,
161
axis2_bool_t *dp_is_early_node_valid,
162
axis2_bool_t dont_care_minoccurs)
164
axiom_node_t *parent = *dp_parent;
166
axis2_status_t status = AXIS2_SUCCESS;
168
void *element = NULL;
170
axis2_char_t* text_value = NULL;
171
axutil_qname_t *qname = NULL;
174
axutil_array_list_t *arr_list = NULL;
176
int sequence_broken = 0;
177
axiom_node_t *tmp_node = NULL;
179
axutil_qname_t *element_qname = NULL;
181
axiom_node_t *first_node = NULL;
182
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
183
axiom_node_t *current_node = NULL;
184
axiom_element_t *current_element = NULL;
186
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
187
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
191
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
193
parent = axiom_node_get_next_sibling(parent, env);
197
/* This should be checked before everything */
198
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
199
"Failed in building adb object for rebootInstancesType : "
200
"NULL elemenet can not be passed to deserialize");
201
return AXIS2_FAILURE;
205
first_node = axiom_node_get_first_child(parent, env);
211
* building correlationId element
216
current_node = first_node;
217
is_early_node_valid = AXIS2_FALSE;
220
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
222
current_node = axiom_node_get_next_sibling(current_node, env);
224
if(current_node != NULL)
226
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
227
qname = axiom_element_get_qname(current_element, env, current_node);
230
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
234
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
236
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
238
is_early_node_valid = AXIS2_TRUE;
242
text_value = axiom_element_get_text(current_element, env, current_node);
243
if(text_value != NULL)
245
status = adb_rebootInstancesType_set_correlationId(_rebootInstancesType, env,
252
* axis2_qname_t *qname = NULL;
253
* axiom_attribute_t *the_attri = NULL;
255
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
256
* the_attri = axiom_element_get_attribute(current_element, env, qname);
258
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
260
axiom_attribute_t *the_attri = NULL;
261
axis2_char_t *attrib_text = NULL;
262
axutil_hash_t *attribute_hash = NULL;
264
attribute_hash = axiom_element_get_all_attributes(current_element, env);
269
axutil_hash_index_t *hi;
273
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
275
axutil_hash_this(hi, &key, NULL, &val);
277
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
279
the_attri = (axiom_attribute_t*)val;
287
attrib_text = axiom_attribute_get_value(the_attri, env);
291
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
292
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
295
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
297
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
298
status = AXIS2_FAILURE;
302
/* after all, we found this is a empty string */
303
status = adb_rebootInstancesType_set_correlationId(_rebootInstancesType, env,
308
if(AXIS2_FAILURE == status)
310
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
313
axutil_qname_free(element_qname, env);
315
return AXIS2_FAILURE;
321
axutil_qname_free(element_qname, env);
322
element_qname = NULL;
328
* building userId element
334
* because elements are ordered this works fine
338
if(current_node != NULL && is_early_node_valid)
340
current_node = axiom_node_get_next_sibling(current_node, env);
343
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
345
current_node = axiom_node_get_next_sibling(current_node, env);
347
if(current_node != NULL)
349
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
350
qname = axiom_element_get_qname(current_element, env, current_node);
354
is_early_node_valid = AXIS2_FALSE;
356
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
360
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
362
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
364
is_early_node_valid = AXIS2_TRUE;
368
text_value = axiom_element_get_text(current_element, env, current_node);
369
if(text_value != NULL)
371
status = adb_rebootInstancesType_set_userId(_rebootInstancesType, env,
378
* axis2_qname_t *qname = NULL;
379
* axiom_attribute_t *the_attri = NULL;
381
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
382
* the_attri = axiom_element_get_attribute(current_element, env, qname);
384
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
386
axiom_attribute_t *the_attri = NULL;
387
axis2_char_t *attrib_text = NULL;
388
axutil_hash_t *attribute_hash = NULL;
390
attribute_hash = axiom_element_get_all_attributes(current_element, env);
395
axutil_hash_index_t *hi;
399
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
401
axutil_hash_this(hi, &key, NULL, &val);
403
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
405
the_attri = (axiom_attribute_t*)val;
413
attrib_text = axiom_attribute_get_value(the_attri, env);
417
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
418
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
421
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
423
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
424
status = AXIS2_FAILURE;
428
/* after all, we found this is a empty string */
429
status = adb_rebootInstancesType_set_userId(_rebootInstancesType, env,
434
if(AXIS2_FAILURE == status)
436
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
439
axutil_qname_free(element_qname, env);
441
return AXIS2_FAILURE;
447
axutil_qname_free(element_qname, env);
448
element_qname = NULL;
454
* building statusMessage element
460
* because elements are ordered this works fine
464
if(current_node != NULL && is_early_node_valid)
466
current_node = axiom_node_get_next_sibling(current_node, env);
469
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
471
current_node = axiom_node_get_next_sibling(current_node, env);
473
if(current_node != NULL)
475
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
476
qname = axiom_element_get_qname(current_element, env, current_node);
480
is_early_node_valid = AXIS2_FALSE;
482
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
486
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
488
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
490
is_early_node_valid = AXIS2_TRUE;
494
text_value = axiom_element_get_text(current_element, env, current_node);
495
if(text_value != NULL)
497
status = adb_rebootInstancesType_set_statusMessage(_rebootInstancesType, env,
501
if(AXIS2_FAILURE == status)
503
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
506
axutil_qname_free(element_qname, env);
508
return AXIS2_FAILURE;
514
axutil_qname_free(element_qname, env);
515
element_qname = NULL;
521
* building return element
527
* because elements are ordered this works fine
531
if(current_node != NULL && is_early_node_valid)
533
current_node = axiom_node_get_next_sibling(current_node, env);
536
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
538
current_node = axiom_node_get_next_sibling(current_node, env);
540
if(current_node != NULL)
542
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
543
qname = axiom_element_get_qname(current_element, env, current_node);
547
is_early_node_valid = AXIS2_FALSE;
549
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
553
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
555
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
557
is_early_node_valid = AXIS2_TRUE;
561
text_value = axiom_element_get_text(current_element, env, current_node);
562
if(text_value != NULL)
564
if (!axutil_strcasecmp(text_value , "true"))
566
status = adb_rebootInstancesType_set_return(_rebootInstancesType, env,
571
status = adb_rebootInstancesType_set_return(_rebootInstancesType, env,
578
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
579
status = AXIS2_FAILURE;
582
if(AXIS2_FAILURE == status)
584
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
587
axutil_qname_free(element_qname, env);
589
return AXIS2_FAILURE;
595
axutil_qname_free(element_qname, env);
596
element_qname = NULL;
600
* building instanceIds array
602
arr_list = axutil_array_list_create(env, 10);
607
* building instanceIds element
612
element_qname = axutil_qname_create(env, "instanceIds", "http://eucalyptus.ucsb.edu/", NULL);
615
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;)
618
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
620
current_node =axiom_node_get_next_sibling(current_node, env);
621
is_early_node_valid = AXIS2_FALSE;
625
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
626
qname = axiom_element_get_qname(current_element, env, current_node);
628
if (axutil_qname_equals(element_qname, env, qname))
631
is_early_node_valid = AXIS2_TRUE;
634
text_value = axiom_element_get_text(current_element, env, current_node);
635
if(text_value != NULL)
637
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
643
* axis2_qname_t *qname = NULL;
644
* axiom_attribute_t *the_attri = NULL;
646
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
647
* the_attri = axiom_element_get_attribute(current_element, env, qname);
650
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
652
axiom_attribute_t *the_attri = NULL;
653
axis2_char_t *attrib_text = NULL;
654
axutil_hash_t *attribute_hash = NULL;
656
attribute_hash = axiom_element_get_all_attributes(current_element, env);
661
axutil_hash_index_t *hi;
665
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
667
axutil_hash_this(hi, &key, NULL, &val);
669
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
671
the_attri = (axiom_attribute_t*)val;
679
attrib_text = axiom_attribute_get_value(the_attri, env);
683
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
684
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
687
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
689
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceIds");
690
status = AXIS2_FAILURE;
694
/* after all, we found this is a empty string */
695
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
699
if(AXIS2_FAILURE == status)
701
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceIds ");
704
axutil_qname_free(element_qname, env);
708
axutil_array_list_free(arr_list, env);
710
return AXIS2_FAILURE;
714
current_node = axiom_node_get_next_sibling(current_node, env);
718
is_early_node_valid = AXIS2_FALSE;
727
/* found element out of order */
728
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceIds (@minOccurs = '0') only have %d elements", i);
731
axutil_qname_free(element_qname, env);
735
axutil_array_list_free(arr_list, env);
737
return AXIS2_FAILURE;
741
if(0 == axutil_array_list_size(arr_list,env))
743
axutil_array_list_free(arr_list, env);
747
status = adb_rebootInstancesType_set_instanceIds(_rebootInstancesType, env,
754
axutil_qname_free(element_qname, env);
755
element_qname = NULL;
761
axis2_bool_t AXIS2_CALL
762
adb_rebootInstancesType_is_particle()
771
adb_rebootInstancesType_declare_parent_namespaces(
772
adb_rebootInstancesType_t* _rebootInstancesType,
773
const axutil_env_t *env, axiom_element_t *parent_element,
774
axutil_hash_t *namespaces, int *next_ns_index)
777
/* Here this is an empty function, Nothing to declare */
783
axiom_node_t* AXIS2_CALL
784
adb_rebootInstancesType_serialize(
785
adb_rebootInstancesType_t* _rebootInstancesType,
786
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)
790
axis2_char_t *string_to_stream;
793
axiom_node_t *current_node = NULL;
798
axiom_namespace_t *ns1 = NULL;
800
axis2_char_t *qname_uri = NULL;
801
axis2_char_t *qname_prefix = NULL;
802
axis2_char_t *p_prefix = NULL;
803
axis2_bool_t ns_already_defined;
807
void *element = NULL;
809
axis2_char_t *text_value_1;
810
axis2_char_t *text_value_1_temp;
812
axis2_char_t *text_value_2;
813
axis2_char_t *text_value_2_temp;
815
axis2_char_t *text_value_3;
816
axis2_char_t *text_value_3_temp;
818
axis2_char_t text_value_4[64];
820
axis2_char_t *text_value_5;
821
axis2_char_t *text_value_5_temp;
823
axis2_char_t *start_input_str = NULL;
824
axis2_char_t *end_input_str = NULL;
825
unsigned int start_input_str_len = 0;
826
unsigned int end_input_str_len = 0;
829
axiom_data_source_t *data_source = NULL;
830
axutil_stream_t *stream = NULL;
834
AXIS2_ENV_CHECK(env, NULL);
835
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
838
current_node = parent;
839
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
842
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
846
if(!parent_tag_closed)
849
string_to_stream = ">";
850
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
855
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
857
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
858
sprintf(p_prefix, "n%d", (*next_ns_index)++);
859
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
861
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
862
"http://eucalyptus.ucsb.edu/",
867
if (!_rebootInstancesType->is_valid_correlationId)
870
/* no need to complain for minoccurs=0 element */
876
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
877
(4 + axutil_strlen(p_prefix) +
878
axutil_strlen("correlationId")));
880
/* axutil_strlen("<:>") + 1 = 4 */
881
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
882
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
883
/* axutil_strlen("</:>") + 1 = 5 */
891
* parsing correlationId element
896
sprintf(start_input_str, "<%s%scorrelationId>",
897
p_prefix?p_prefix:"",
898
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
900
start_input_str_len = axutil_strlen(start_input_str);
901
sprintf(end_input_str, "</%s%scorrelationId>",
902
p_prefix?p_prefix:"",
903
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
904
end_input_str_len = axutil_strlen(end_input_str);
906
text_value_1 = _rebootInstancesType->property_correlationId;
908
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
911
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
912
if (text_value_1_temp)
914
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
915
AXIS2_FREE(env->allocator, text_value_1_temp);
919
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
922
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
925
AXIS2_FREE(env->allocator,start_input_str);
926
AXIS2_FREE(env->allocator,end_input_str);
930
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
932
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
933
sprintf(p_prefix, "n%d", (*next_ns_index)++);
934
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
936
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
937
"http://eucalyptus.ucsb.edu/",
942
if (!_rebootInstancesType->is_valid_userId)
945
/* no need to complain for minoccurs=0 element */
951
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
952
(4 + axutil_strlen(p_prefix) +
953
axutil_strlen("userId")));
955
/* axutil_strlen("<:>") + 1 = 4 */
956
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
957
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
958
/* axutil_strlen("</:>") + 1 = 5 */
966
* parsing userId element
971
sprintf(start_input_str, "<%s%suserId>",
972
p_prefix?p_prefix:"",
973
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
975
start_input_str_len = axutil_strlen(start_input_str);
976
sprintf(end_input_str, "</%s%suserId>",
977
p_prefix?p_prefix:"",
978
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
979
end_input_str_len = axutil_strlen(end_input_str);
981
text_value_2 = _rebootInstancesType->property_userId;
983
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
986
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
987
if (text_value_2_temp)
989
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
990
AXIS2_FREE(env->allocator, text_value_2_temp);
994
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
997
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1000
AXIS2_FREE(env->allocator,start_input_str);
1001
AXIS2_FREE(env->allocator,end_input_str);
1005
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1007
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1008
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1009
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1011
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1012
"http://eucalyptus.ucsb.edu/",
1017
if (!_rebootInstancesType->is_valid_statusMessage)
1020
/* no need to complain for minoccurs=0 element */
1026
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1027
(4 + axutil_strlen(p_prefix) +
1028
axutil_strlen("statusMessage")));
1030
/* axutil_strlen("<:>") + 1 = 4 */
1031
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1032
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1033
/* axutil_strlen("</:>") + 1 = 5 */
1041
* parsing statusMessage element
1046
sprintf(start_input_str, "<%s%sstatusMessage>",
1047
p_prefix?p_prefix:"",
1048
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1050
start_input_str_len = axutil_strlen(start_input_str);
1051
sprintf(end_input_str, "</%s%sstatusMessage>",
1052
p_prefix?p_prefix:"",
1053
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1054
end_input_str_len = axutil_strlen(end_input_str);
1056
text_value_3 = _rebootInstancesType->property_statusMessage;
1058
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1061
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1062
if (text_value_3_temp)
1064
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1065
AXIS2_FREE(env->allocator, text_value_3_temp);
1069
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1072
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1075
AXIS2_FREE(env->allocator,start_input_str);
1076
AXIS2_FREE(env->allocator,end_input_str);
1080
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1082
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1083
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1084
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1086
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1087
"http://eucalyptus.ucsb.edu/",
1092
if (!_rebootInstancesType->is_valid_return)
1095
/* no need to complain for minoccurs=0 element */
1101
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1102
(4 + axutil_strlen(p_prefix) +
1103
axutil_strlen("return")));
1105
/* axutil_strlen("<:>") + 1 = 4 */
1106
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1107
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1108
/* axutil_strlen("</:>") + 1 = 5 */
1116
* parsing return element
1121
sprintf(start_input_str, "<%s%sreturn>",
1122
p_prefix?p_prefix:"",
1123
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1125
start_input_str_len = axutil_strlen(start_input_str);
1126
sprintf(end_input_str, "</%s%sreturn>",
1127
p_prefix?p_prefix:"",
1128
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1129
end_input_str_len = axutil_strlen(end_input_str);
1131
strcpy(text_value_4, (_rebootInstancesType->property_return)?"true":"false");
1133
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1135
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1137
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1140
AXIS2_FREE(env->allocator,start_input_str);
1141
AXIS2_FREE(env->allocator,end_input_str);
1145
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1147
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1148
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1149
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1151
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1152
"http://eucalyptus.ucsb.edu/",
1157
if (!_rebootInstancesType->is_valid_instanceIds)
1160
/* no need to complain for minoccurs=0 element */
1166
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1167
(4 + axutil_strlen(p_prefix) +
1168
axutil_strlen("instanceIds")));
1170
/* axutil_strlen("<:>") + 1 = 4 */
1171
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1172
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceIds")));
1173
/* axutil_strlen("</:>") + 1 = 5 */
1180
* Parsing instanceIds array
1182
if (_rebootInstancesType->property_instanceIds != NULL)
1185
sprintf(start_input_str, "<%s%sinstanceIds>",
1186
p_prefix?p_prefix:"",
1187
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1189
start_input_str_len = axutil_strlen(start_input_str);
1191
sprintf(end_input_str, "</%s%sinstanceIds>",
1192
p_prefix?p_prefix:"",
1193
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1194
end_input_str_len = axutil_strlen(end_input_str);
1196
count = axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
1197
for(i = 0; i < count; i ++)
1199
element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1208
* parsing instanceIds element
1213
text_value_5 = (axis2_char_t*)element;
1215
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1218
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1219
if (text_value_5_temp)
1221
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1222
AXIS2_FREE(env->allocator, text_value_5_temp);
1226
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1229
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1235
AXIS2_FREE(env->allocator,start_input_str);
1236
AXIS2_FREE(env->allocator,end_input_str);
1248
* getter for correlationId.
1250
axis2_char_t* AXIS2_CALL
1251
adb_rebootInstancesType_get_correlationId(
1252
adb_rebootInstancesType_t* _rebootInstancesType,
1253
const axutil_env_t *env)
1256
AXIS2_ENV_CHECK(env, NULL);
1257
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1260
return _rebootInstancesType->property_correlationId;
1264
* setter for correlationId
1266
axis2_status_t AXIS2_CALL
1267
adb_rebootInstancesType_set_correlationId(
1268
adb_rebootInstancesType_t* _rebootInstancesType,
1269
const axutil_env_t *env,
1270
const axis2_char_t* arg_correlationId)
1274
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1275
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1277
if(_rebootInstancesType->is_valid_correlationId &&
1278
arg_correlationId == _rebootInstancesType->property_correlationId)
1281
return AXIS2_SUCCESS;
1284
adb_rebootInstancesType_reset_correlationId(_rebootInstancesType, env);
1287
if(NULL == arg_correlationId)
1289
/* We are already done */
1290
return AXIS2_SUCCESS;
1292
_rebootInstancesType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1293
if(NULL == _rebootInstancesType->property_correlationId)
1295
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1296
return AXIS2_FAILURE;
1298
_rebootInstancesType->is_valid_correlationId = AXIS2_TRUE;
1300
return AXIS2_SUCCESS;
1306
* resetter for correlationId
1308
axis2_status_t AXIS2_CALL
1309
adb_rebootInstancesType_reset_correlationId(
1310
adb_rebootInstancesType_t* _rebootInstancesType,
1311
const axutil_env_t *env)
1315
void *element = NULL;
1317
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1318
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1324
if(_rebootInstancesType->property_correlationId != NULL)
1328
AXIS2_FREE(env-> allocator, _rebootInstancesType->property_correlationId);
1329
_rebootInstancesType->property_correlationId = NULL;
1334
_rebootInstancesType->is_valid_correlationId = AXIS2_FALSE;
1335
return AXIS2_SUCCESS;
1339
* Check whether correlationId is nill
1341
axis2_bool_t AXIS2_CALL
1342
adb_rebootInstancesType_is_correlationId_nil(
1343
adb_rebootInstancesType_t* _rebootInstancesType,
1344
const axutil_env_t *env)
1346
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1347
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1349
return !_rebootInstancesType->is_valid_correlationId;
1353
* Set correlationId to nill (currently the same as reset)
1355
axis2_status_t AXIS2_CALL
1356
adb_rebootInstancesType_set_correlationId_nil(
1357
adb_rebootInstancesType_t* _rebootInstancesType,
1358
const axutil_env_t *env)
1360
return adb_rebootInstancesType_reset_correlationId(_rebootInstancesType, env);
1366
* getter for userId.
1368
axis2_char_t* AXIS2_CALL
1369
adb_rebootInstancesType_get_userId(
1370
adb_rebootInstancesType_t* _rebootInstancesType,
1371
const axutil_env_t *env)
1374
AXIS2_ENV_CHECK(env, NULL);
1375
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1378
return _rebootInstancesType->property_userId;
1384
axis2_status_t AXIS2_CALL
1385
adb_rebootInstancesType_set_userId(
1386
adb_rebootInstancesType_t* _rebootInstancesType,
1387
const axutil_env_t *env,
1388
const axis2_char_t* arg_userId)
1392
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1393
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1395
if(_rebootInstancesType->is_valid_userId &&
1396
arg_userId == _rebootInstancesType->property_userId)
1399
return AXIS2_SUCCESS;
1402
adb_rebootInstancesType_reset_userId(_rebootInstancesType, env);
1405
if(NULL == arg_userId)
1407
/* We are already done */
1408
return AXIS2_SUCCESS;
1410
_rebootInstancesType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1411
if(NULL == _rebootInstancesType->property_userId)
1413
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1414
return AXIS2_FAILURE;
1416
_rebootInstancesType->is_valid_userId = AXIS2_TRUE;
1418
return AXIS2_SUCCESS;
1424
* resetter for userId
1426
axis2_status_t AXIS2_CALL
1427
adb_rebootInstancesType_reset_userId(
1428
adb_rebootInstancesType_t* _rebootInstancesType,
1429
const axutil_env_t *env)
1433
void *element = NULL;
1435
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1436
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1442
if(_rebootInstancesType->property_userId != NULL)
1446
AXIS2_FREE(env-> allocator, _rebootInstancesType->property_userId);
1447
_rebootInstancesType->property_userId = NULL;
1452
_rebootInstancesType->is_valid_userId = AXIS2_FALSE;
1453
return AXIS2_SUCCESS;
1457
* Check whether userId is nill
1459
axis2_bool_t AXIS2_CALL
1460
adb_rebootInstancesType_is_userId_nil(
1461
adb_rebootInstancesType_t* _rebootInstancesType,
1462
const axutil_env_t *env)
1464
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1465
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1467
return !_rebootInstancesType->is_valid_userId;
1471
* Set userId to nill (currently the same as reset)
1473
axis2_status_t AXIS2_CALL
1474
adb_rebootInstancesType_set_userId_nil(
1475
adb_rebootInstancesType_t* _rebootInstancesType,
1476
const axutil_env_t *env)
1478
return adb_rebootInstancesType_reset_userId(_rebootInstancesType, env);
1484
* getter for statusMessage.
1486
axis2_char_t* AXIS2_CALL
1487
adb_rebootInstancesType_get_statusMessage(
1488
adb_rebootInstancesType_t* _rebootInstancesType,
1489
const axutil_env_t *env)
1492
AXIS2_ENV_CHECK(env, NULL);
1493
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1496
return _rebootInstancesType->property_statusMessage;
1500
* setter for statusMessage
1502
axis2_status_t AXIS2_CALL
1503
adb_rebootInstancesType_set_statusMessage(
1504
adb_rebootInstancesType_t* _rebootInstancesType,
1505
const axutil_env_t *env,
1506
const axis2_char_t* arg_statusMessage)
1510
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1511
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1513
if(_rebootInstancesType->is_valid_statusMessage &&
1514
arg_statusMessage == _rebootInstancesType->property_statusMessage)
1517
return AXIS2_SUCCESS;
1520
adb_rebootInstancesType_reset_statusMessage(_rebootInstancesType, env);
1523
if(NULL == arg_statusMessage)
1525
/* We are already done */
1526
return AXIS2_SUCCESS;
1528
_rebootInstancesType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1529
if(NULL == _rebootInstancesType->property_statusMessage)
1531
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1532
return AXIS2_FAILURE;
1534
_rebootInstancesType->is_valid_statusMessage = AXIS2_TRUE;
1536
return AXIS2_SUCCESS;
1542
* resetter for statusMessage
1544
axis2_status_t AXIS2_CALL
1545
adb_rebootInstancesType_reset_statusMessage(
1546
adb_rebootInstancesType_t* _rebootInstancesType,
1547
const axutil_env_t *env)
1551
void *element = NULL;
1553
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1554
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1560
if(_rebootInstancesType->property_statusMessage != NULL)
1564
AXIS2_FREE(env-> allocator, _rebootInstancesType->property_statusMessage);
1565
_rebootInstancesType->property_statusMessage = NULL;
1570
_rebootInstancesType->is_valid_statusMessage = AXIS2_FALSE;
1571
return AXIS2_SUCCESS;
1575
* Check whether statusMessage is nill
1577
axis2_bool_t AXIS2_CALL
1578
adb_rebootInstancesType_is_statusMessage_nil(
1579
adb_rebootInstancesType_t* _rebootInstancesType,
1580
const axutil_env_t *env)
1582
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1583
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1585
return !_rebootInstancesType->is_valid_statusMessage;
1589
* Set statusMessage to nill (currently the same as reset)
1591
axis2_status_t AXIS2_CALL
1592
adb_rebootInstancesType_set_statusMessage_nil(
1593
adb_rebootInstancesType_t* _rebootInstancesType,
1594
const axutil_env_t *env)
1596
return adb_rebootInstancesType_reset_statusMessage(_rebootInstancesType, env);
1602
* getter for return.
1604
axis2_bool_t AXIS2_CALL
1605
adb_rebootInstancesType_get_return(
1606
adb_rebootInstancesType_t* _rebootInstancesType,
1607
const axutil_env_t *env)
1610
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1611
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, (axis2_bool_t)0);
1614
return _rebootInstancesType->property_return;
1620
axis2_status_t AXIS2_CALL
1621
adb_rebootInstancesType_set_return(
1622
adb_rebootInstancesType_t* _rebootInstancesType,
1623
const axutil_env_t *env,
1624
axis2_bool_t arg_return)
1628
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1629
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1631
if(_rebootInstancesType->is_valid_return &&
1632
arg_return == _rebootInstancesType->property_return)
1635
return AXIS2_SUCCESS;
1638
adb_rebootInstancesType_reset_return(_rebootInstancesType, env);
1640
_rebootInstancesType->property_return = arg_return;
1641
_rebootInstancesType->is_valid_return = AXIS2_TRUE;
1643
return AXIS2_SUCCESS;
1649
* resetter for return
1651
axis2_status_t AXIS2_CALL
1652
adb_rebootInstancesType_reset_return(
1653
adb_rebootInstancesType_t* _rebootInstancesType,
1654
const axutil_env_t *env)
1658
void *element = NULL;
1660
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1661
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1664
_rebootInstancesType->is_valid_return = AXIS2_FALSE;
1665
return AXIS2_SUCCESS;
1669
* Check whether return is nill
1671
axis2_bool_t AXIS2_CALL
1672
adb_rebootInstancesType_is_return_nil(
1673
adb_rebootInstancesType_t* _rebootInstancesType,
1674
const axutil_env_t *env)
1676
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1677
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1679
return !_rebootInstancesType->is_valid_return;
1683
* Set return to nill (currently the same as reset)
1685
axis2_status_t AXIS2_CALL
1686
adb_rebootInstancesType_set_return_nil(
1687
adb_rebootInstancesType_t* _rebootInstancesType,
1688
const axutil_env_t *env)
1690
return adb_rebootInstancesType_reset_return(_rebootInstancesType, env);
1696
* getter for instanceIds.
1698
axutil_array_list_t* AXIS2_CALL
1699
adb_rebootInstancesType_get_instanceIds(
1700
adb_rebootInstancesType_t* _rebootInstancesType,
1701
const axutil_env_t *env)
1704
AXIS2_ENV_CHECK(env, NULL);
1705
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1708
return _rebootInstancesType->property_instanceIds;
1712
* setter for instanceIds
1714
axis2_status_t AXIS2_CALL
1715
adb_rebootInstancesType_set_instanceIds(
1716
adb_rebootInstancesType_t* _rebootInstancesType,
1717
const axutil_env_t *env,
1718
axutil_array_list_t* arg_instanceIds)
1723
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1726
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1727
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1729
if(_rebootInstancesType->is_valid_instanceIds &&
1730
arg_instanceIds == _rebootInstancesType->property_instanceIds)
1733
return AXIS2_SUCCESS;
1737
size = axutil_array_list_size(arg_instanceIds, env);
1741
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceIds has less than minOccurs(0)");
1742
return AXIS2_FAILURE;
1744
for(i = 0; i < size; i ++ )
1746
if(NULL != axutil_array_list_get(arg_instanceIds, env, i))
1748
non_nil_exists = AXIS2_TRUE;
1753
adb_rebootInstancesType_reset_instanceIds(_rebootInstancesType, env);
1756
if(NULL == arg_instanceIds)
1758
/* We are already done */
1759
return AXIS2_SUCCESS;
1761
_rebootInstancesType->property_instanceIds = arg_instanceIds;
1764
_rebootInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1768
return AXIS2_SUCCESS;
1773
* Get ith element of instanceIds.
1775
axis2_char_t* AXIS2_CALL
1776
adb_rebootInstancesType_get_instanceIds_at(
1777
adb_rebootInstancesType_t* _rebootInstancesType,
1778
const axutil_env_t *env, int i)
1780
axis2_char_t* ret_val;
1783
AXIS2_ENV_CHECK(env, NULL);
1784
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1787
if(_rebootInstancesType->property_instanceIds == NULL)
1789
return (axis2_char_t*)0;
1791
ret_val = (axis2_char_t*)axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1798
* Set the ith element of instanceIds.
1800
axis2_status_t AXIS2_CALL
1801
adb_rebootInstancesType_set_instanceIds_at(
1802
adb_rebootInstancesType_t* _rebootInstancesType,
1803
const axutil_env_t *env, int i,
1804
const axis2_char_t* arg_instanceIds)
1806
void *element = NULL;
1810
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1814
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1815
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1817
if( _rebootInstancesType->is_valid_instanceIds &&
1818
_rebootInstancesType->property_instanceIds &&
1820
arg_instanceIds == (axis2_char_t*)axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i))
1824
return AXIS2_SUCCESS;
1828
if(NULL == arg_instanceIds)
1830
if(_rebootInstancesType->property_instanceIds != NULL)
1832
size = axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
1833
for(j = 0, k = 0; j < size; j ++ )
1835
if(i == j) continue;
1836
if(NULL != axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i))
1839
non_nil_exists = AXIS2_TRUE;
1850
non_nil_exists = AXIS2_TRUE;
1855
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)");
1856
return AXIS2_FAILURE;
1859
if(_rebootInstancesType->property_instanceIds == NULL)
1861
_rebootInstancesType->property_instanceIds = axutil_array_list_create(env, 10);
1864
/* check whether there already exist an element */
1865
element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1871
/* This is an unknown type or a primitive. Please free this manually*/
1879
_rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
1880
axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, NULL);
1882
return AXIS2_SUCCESS;
1885
axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, axutil_strdup(env, arg_instanceIds));
1886
_rebootInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1888
return AXIS2_SUCCESS;
1892
* Add to instanceIds.
1894
axis2_status_t AXIS2_CALL
1895
adb_rebootInstancesType_add_instanceIds(
1896
adb_rebootInstancesType_t* _rebootInstancesType,
1897
const axutil_env_t *env,
1898
const axis2_char_t* arg_instanceIds)
1902
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1903
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1906
if(NULL == arg_instanceIds)
1909
return AXIS2_SUCCESS;
1914
if(_rebootInstancesType->property_instanceIds == NULL)
1916
_rebootInstancesType->property_instanceIds = axutil_array_list_create(env, 10);
1918
if(_rebootInstancesType->property_instanceIds == NULL)
1920
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for instanceIds");
1921
return AXIS2_FAILURE;
1925
axutil_array_list_add(_rebootInstancesType->property_instanceIds , env, axutil_strdup(env, arg_instanceIds));
1926
_rebootInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1927
return AXIS2_SUCCESS;
1931
* Get the size of the instanceIds array.
1934
adb_rebootInstancesType_sizeof_instanceIds(
1935
adb_rebootInstancesType_t* _rebootInstancesType,
1936
const axutil_env_t *env)
1938
AXIS2_ENV_CHECK(env, -1);
1939
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, -1);
1940
if(_rebootInstancesType->property_instanceIds == NULL)
1944
return axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
1948
* remove the ith element, same as set_nil_at.
1950
axis2_status_t AXIS2_CALL
1951
adb_rebootInstancesType_remove_instanceIds_at(
1952
adb_rebootInstancesType_t* _rebootInstancesType,
1953
const axutil_env_t *env, int i)
1955
return adb_rebootInstancesType_set_instanceIds_nil_at(_rebootInstancesType, env, i);
1961
* resetter for instanceIds
1963
axis2_status_t AXIS2_CALL
1964
adb_rebootInstancesType_reset_instanceIds(
1965
adb_rebootInstancesType_t* _rebootInstancesType,
1966
const axutil_env_t *env)
1970
void *element = NULL;
1972
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1973
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1977
if (_rebootInstancesType->property_instanceIds != NULL)
1979
count = axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
1980
for(i = 0; i < count; i ++)
1982
element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1990
AXIS2_FREE(env-> allocator, (axis2_char_t*)element);
1998
axutil_array_list_free(_rebootInstancesType->property_instanceIds, env);
2000
_rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2001
return AXIS2_SUCCESS;
2005
* Check whether instanceIds is nill
2007
axis2_bool_t AXIS2_CALL
2008
adb_rebootInstancesType_is_instanceIds_nil(
2009
adb_rebootInstancesType_t* _rebootInstancesType,
2010
const axutil_env_t *env)
2012
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2013
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
2015
return !_rebootInstancesType->is_valid_instanceIds;
2019
* Set instanceIds to nill (currently the same as reset)
2021
axis2_status_t AXIS2_CALL
2022
adb_rebootInstancesType_set_instanceIds_nil(
2023
adb_rebootInstancesType_t* _rebootInstancesType,
2024
const axutil_env_t *env)
2026
return adb_rebootInstancesType_reset_instanceIds(_rebootInstancesType, env);
2031
* Check whether instanceIds is nill at i
2033
axis2_bool_t AXIS2_CALL
2034
adb_rebootInstancesType_is_instanceIds_nil_at(
2035
adb_rebootInstancesType_t* _rebootInstancesType,
2036
const axutil_env_t *env, int i)
2038
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2039
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
2041
return (_rebootInstancesType->is_valid_instanceIds == AXIS2_FALSE ||
2042
NULL == _rebootInstancesType->property_instanceIds ||
2043
NULL == axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i));
2047
* Set instanceIds to nill at i
2049
axis2_status_t AXIS2_CALL
2050
adb_rebootInstancesType_set_instanceIds_nil_at(
2051
adb_rebootInstancesType_t* _rebootInstancesType,
2052
const axutil_env_t *env, int i)
2054
void *element = NULL;
2057
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2061
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2062
AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
2064
if(_rebootInstancesType->property_instanceIds == NULL ||
2065
_rebootInstancesType->is_valid_instanceIds == AXIS2_FALSE)
2068
non_nil_exists = AXIS2_FALSE;
2072
size = axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
2073
for(j = 0, k = 0; j < size; j ++ )
2075
if(i == j) continue;
2076
if(NULL != axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i))
2079
non_nil_exists = AXIS2_TRUE;
2091
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)");
2092
return AXIS2_FAILURE;
2095
if(_rebootInstancesType->property_instanceIds == NULL)
2097
_rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2099
return AXIS2_SUCCESS;
2102
/* check whether there already exist an element */
2103
element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
2109
/* This is an unknown type or a primitive. Please free this manually*/
2117
_rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2118
axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, NULL);
2119
return AXIS2_SUCCESS;
2124
axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, NULL);
2126
return AXIS2_SUCCESS;
added
removed
cluster/generated/adb_rebootInstancesType.c
