4
* adb_ncDescribeInstancesType.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_ncDescribeInstancesType.h"
13
* This type was generated from the piece of schema that had
14
* name = ncDescribeInstancesType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_ncDescribeInstancesType
23
axis2_char_t* property_correlationId;
26
axis2_bool_t is_valid_correlationId;
29
axis2_char_t* property_userId;
32
axis2_bool_t is_valid_userId;
35
axis2_bool_t property_return;
38
axis2_bool_t is_valid_return;
41
int property_statusMessage;
44
axis2_bool_t is_valid_statusMessage;
47
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_ncDescribeInstancesType_set_correlationId_nil(
62
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
63
const axutil_env_t *env);
66
axis2_status_t AXIS2_CALL
67
adb_ncDescribeInstancesType_set_userId_nil(
68
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_ncDescribeInstancesType_set_return_nil(
74
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
75
const axutil_env_t *env);
77
axis2_status_t AXIS2_CALL
78
adb_ncDescribeInstancesType_set_instanceIds_nil_at(
79
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
80
const axutil_env_t *env, int i);
83
axis2_status_t AXIS2_CALL
84
adb_ncDescribeInstancesType_set_instanceIds_nil(
85
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
86
const axutil_env_t *env);
90
/************************* Function Implmentations ********************************/
91
adb_ncDescribeInstancesType_t* AXIS2_CALL
92
adb_ncDescribeInstancesType_create(
93
const axutil_env_t *env)
95
adb_ncDescribeInstancesType_t *_ncDescribeInstancesType = NULL;
97
AXIS2_ENV_CHECK(env, NULL);
99
_ncDescribeInstancesType = (adb_ncDescribeInstancesType_t *) AXIS2_MALLOC(env->
100
allocator, sizeof(adb_ncDescribeInstancesType_t));
102
if(NULL == _ncDescribeInstancesType)
104
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
108
memset(_ncDescribeInstancesType, 0, sizeof(adb_ncDescribeInstancesType_t));
110
_ncDescribeInstancesType->property_correlationId = NULL;
111
_ncDescribeInstancesType->is_valid_correlationId = AXIS2_FALSE;
112
_ncDescribeInstancesType->property_userId = NULL;
113
_ncDescribeInstancesType->is_valid_userId = AXIS2_FALSE;
114
_ncDescribeInstancesType->is_valid_return = AXIS2_FALSE;
115
_ncDescribeInstancesType->is_valid_statusMessage = AXIS2_FALSE;
116
_ncDescribeInstancesType->property_instanceIds = NULL;
117
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_FALSE;
120
return _ncDescribeInstancesType;
123
axis2_status_t AXIS2_CALL
124
adb_ncDescribeInstancesType_free (
125
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
126
const axutil_env_t *env)
131
void *element = NULL;
134
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
135
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
137
adb_ncDescribeInstancesType_reset_correlationId(_ncDescribeInstancesType, env);
138
adb_ncDescribeInstancesType_reset_userId(_ncDescribeInstancesType, env);
139
adb_ncDescribeInstancesType_reset_return(_ncDescribeInstancesType, env);
140
adb_ncDescribeInstancesType_reset_statusMessage(_ncDescribeInstancesType, env);
141
adb_ncDescribeInstancesType_reset_instanceIds(_ncDescribeInstancesType, env);
144
if(_ncDescribeInstancesType)
146
AXIS2_FREE(env->allocator, _ncDescribeInstancesType);
147
_ncDescribeInstancesType = NULL;
149
return AXIS2_SUCCESS;
155
axis2_status_t AXIS2_CALL
156
adb_ncDescribeInstancesType_deserialize(
157
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
158
const axutil_env_t *env,
159
axiom_node_t **dp_parent,
160
axis2_bool_t *dp_is_early_node_valid,
161
axis2_bool_t dont_care_minoccurs)
163
axiom_node_t *parent = *dp_parent;
165
axis2_status_t status = AXIS2_SUCCESS;
167
void *element = NULL;
169
axis2_char_t* text_value = NULL;
170
axutil_qname_t *qname = NULL;
173
axutil_array_list_t *arr_list = NULL;
175
int sequence_broken = 0;
176
axiom_node_t *tmp_node = NULL;
178
axutil_qname_t *element_qname = NULL;
180
axiom_node_t *first_node = NULL;
181
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
182
axiom_node_t *current_node = NULL;
183
axiom_element_t *current_element = NULL;
185
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
186
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
190
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
192
parent = axiom_node_get_next_sibling(parent, env);
196
/* This should be checked before everything */
197
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
198
"Failed in building adb object for ncDescribeInstancesType : "
199
"NULL elemenet can not be passed to deserialize");
200
return AXIS2_FAILURE;
204
first_node = axiom_node_get_first_child(parent, env);
210
* building correlationId element
215
current_node = first_node;
216
is_early_node_valid = AXIS2_FALSE;
219
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
221
current_node = axiom_node_get_next_sibling(current_node, env);
223
if(current_node != NULL)
225
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
226
qname = axiom_element_get_qname(current_element, env, current_node);
229
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
233
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
235
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
237
is_early_node_valid = AXIS2_TRUE;
241
text_value = axiom_element_get_text(current_element, env, current_node);
242
if(text_value != NULL)
244
status = adb_ncDescribeInstancesType_set_correlationId(_ncDescribeInstancesType, env,
251
* axis2_qname_t *qname = NULL;
252
* axiom_attribute_t *the_attri = NULL;
254
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
255
* the_attri = axiom_element_get_attribute(current_element, env, qname);
257
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
259
axiom_attribute_t *the_attri = NULL;
260
axis2_char_t *attrib_text = NULL;
261
axutil_hash_t *attribute_hash = NULL;
263
attribute_hash = axiom_element_get_all_attributes(current_element, env);
268
axutil_hash_index_t *hi;
272
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
274
axutil_hash_this(hi, &key, NULL, &val);
276
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
278
the_attri = (axiom_attribute_t*)val;
286
attrib_text = axiom_attribute_get_value(the_attri, env);
290
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
291
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
294
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
296
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
297
status = AXIS2_FAILURE;
301
/* after all, we found this is a empty string */
302
status = adb_ncDescribeInstancesType_set_correlationId(_ncDescribeInstancesType, env,
307
if(AXIS2_FAILURE == status)
309
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
312
axutil_qname_free(element_qname, env);
314
return AXIS2_FAILURE;
320
axutil_qname_free(element_qname, env);
321
element_qname = NULL;
327
* building userId element
333
* because elements are ordered this works fine
337
if(current_node != NULL && is_early_node_valid)
339
current_node = axiom_node_get_next_sibling(current_node, env);
342
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
344
current_node = axiom_node_get_next_sibling(current_node, env);
346
if(current_node != NULL)
348
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
349
qname = axiom_element_get_qname(current_element, env, current_node);
353
is_early_node_valid = AXIS2_FALSE;
355
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
359
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
361
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
363
is_early_node_valid = AXIS2_TRUE;
367
text_value = axiom_element_get_text(current_element, env, current_node);
368
if(text_value != NULL)
370
status = adb_ncDescribeInstancesType_set_userId(_ncDescribeInstancesType, env,
377
* axis2_qname_t *qname = NULL;
378
* axiom_attribute_t *the_attri = NULL;
380
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
381
* the_attri = axiom_element_get_attribute(current_element, env, qname);
383
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
385
axiom_attribute_t *the_attri = NULL;
386
axis2_char_t *attrib_text = NULL;
387
axutil_hash_t *attribute_hash = NULL;
389
attribute_hash = axiom_element_get_all_attributes(current_element, env);
394
axutil_hash_index_t *hi;
398
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
400
axutil_hash_this(hi, &key, NULL, &val);
402
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
404
the_attri = (axiom_attribute_t*)val;
412
attrib_text = axiom_attribute_get_value(the_attri, env);
416
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
417
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
420
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
422
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
423
status = AXIS2_FAILURE;
427
/* after all, we found this is a empty string */
428
status = adb_ncDescribeInstancesType_set_userId(_ncDescribeInstancesType, env,
433
if(AXIS2_FAILURE == status)
435
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
438
axutil_qname_free(element_qname, env);
440
return AXIS2_FAILURE;
446
axutil_qname_free(element_qname, env);
447
element_qname = NULL;
453
* building return element
459
* because elements are ordered this works fine
463
if(current_node != NULL && is_early_node_valid)
465
current_node = axiom_node_get_next_sibling(current_node, env);
468
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
470
current_node = axiom_node_get_next_sibling(current_node, env);
472
if(current_node != NULL)
474
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
475
qname = axiom_element_get_qname(current_element, env, current_node);
479
is_early_node_valid = AXIS2_FALSE;
481
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
485
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
487
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
489
is_early_node_valid = AXIS2_TRUE;
493
text_value = axiom_element_get_text(current_element, env, current_node);
494
if(text_value != NULL)
496
if (!axutil_strcasecmp(text_value , "true"))
498
status = adb_ncDescribeInstancesType_set_return(_ncDescribeInstancesType, env,
503
status = adb_ncDescribeInstancesType_set_return(_ncDescribeInstancesType, env,
510
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
511
status = AXIS2_FAILURE;
514
if(AXIS2_FAILURE == status)
516
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
519
axutil_qname_free(element_qname, env);
521
return AXIS2_FAILURE;
527
axutil_qname_free(element_qname, env);
528
element_qname = NULL;
534
* building statusMessage element
540
* because elements are ordered this works fine
544
if(current_node != NULL && is_early_node_valid)
546
current_node = axiom_node_get_next_sibling(current_node, env);
549
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
551
current_node = axiom_node_get_next_sibling(current_node, env);
553
if(current_node != NULL)
555
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
556
qname = axiom_element_get_qname(current_element, env, current_node);
560
is_early_node_valid = AXIS2_FALSE;
562
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
566
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
568
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
570
is_early_node_valid = AXIS2_TRUE;
574
text_value = axiom_element_get_text(current_element, env, current_node);
575
if(text_value != NULL)
577
status = adb_ncDescribeInstancesType_set_statusMessage(_ncDescribeInstancesType, env,
581
if(AXIS2_FAILURE == status)
583
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
586
axutil_qname_free(element_qname, env);
588
return AXIS2_FAILURE;
594
axutil_qname_free(element_qname, env);
595
element_qname = NULL;
599
* building instanceIds array
601
arr_list = axutil_array_list_create(env, 10);
606
* building instanceIds element
611
element_qname = axutil_qname_create(env, "instanceIds", "http://eucalyptus.ucsb.edu/", NULL);
614
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;)
617
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
619
current_node =axiom_node_get_next_sibling(current_node, env);
620
is_early_node_valid = AXIS2_FALSE;
624
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
625
qname = axiom_element_get_qname(current_element, env, current_node);
627
if (axutil_qname_equals(element_qname, env, qname))
630
is_early_node_valid = AXIS2_TRUE;
633
text_value = axiom_element_get_text(current_element, env, current_node);
634
if(text_value != NULL)
636
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
642
* axis2_qname_t *qname = NULL;
643
* axiom_attribute_t *the_attri = NULL;
645
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
646
* the_attri = axiom_element_get_attribute(current_element, env, qname);
649
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
651
axiom_attribute_t *the_attri = NULL;
652
axis2_char_t *attrib_text = NULL;
653
axutil_hash_t *attribute_hash = NULL;
655
attribute_hash = axiom_element_get_all_attributes(current_element, env);
660
axutil_hash_index_t *hi;
664
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
666
axutil_hash_this(hi, &key, NULL, &val);
668
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
670
the_attri = (axiom_attribute_t*)val;
678
attrib_text = axiom_attribute_get_value(the_attri, env);
682
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
683
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
686
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
688
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceIds");
689
status = AXIS2_FAILURE;
693
/* after all, we found this is a empty string */
694
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
698
if(AXIS2_FAILURE == status)
700
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceIds ");
703
axutil_qname_free(element_qname, env);
707
axutil_array_list_free(arr_list, env);
709
return AXIS2_FAILURE;
713
current_node = axiom_node_get_next_sibling(current_node, env);
717
is_early_node_valid = AXIS2_FALSE;
726
/* found element out of order */
727
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceIds (@minOccurs = '0') only have %d elements", i);
730
axutil_qname_free(element_qname, env);
734
axutil_array_list_free(arr_list, env);
736
return AXIS2_FAILURE;
740
if(0 == axutil_array_list_size(arr_list,env))
742
axutil_array_list_free(arr_list, env);
746
status = adb_ncDescribeInstancesType_set_instanceIds(_ncDescribeInstancesType, env,
753
axutil_qname_free(element_qname, env);
754
element_qname = NULL;
760
axis2_bool_t AXIS2_CALL
761
adb_ncDescribeInstancesType_is_particle()
770
adb_ncDescribeInstancesType_declare_parent_namespaces(
771
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
772
const axutil_env_t *env, axiom_element_t *parent_element,
773
axutil_hash_t *namespaces, int *next_ns_index)
776
/* Here this is an empty function, Nothing to declare */
782
axiom_node_t* AXIS2_CALL
783
adb_ncDescribeInstancesType_serialize(
784
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
785
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)
789
axis2_char_t *string_to_stream;
792
axiom_node_t *current_node = NULL;
797
axiom_namespace_t *ns1 = NULL;
799
axis2_char_t *qname_uri = NULL;
800
axis2_char_t *qname_prefix = NULL;
801
axis2_char_t *p_prefix = NULL;
802
axis2_bool_t ns_already_defined;
806
void *element = NULL;
808
axis2_char_t *text_value_1;
809
axis2_char_t *text_value_1_temp;
811
axis2_char_t *text_value_2;
812
axis2_char_t *text_value_2_temp;
814
axis2_char_t text_value_3[64];
816
axis2_char_t text_value_4[64];
818
axis2_char_t *text_value_5;
819
axis2_char_t *text_value_5_temp;
821
axis2_char_t *start_input_str = NULL;
822
axis2_char_t *end_input_str = NULL;
823
unsigned int start_input_str_len = 0;
824
unsigned int end_input_str_len = 0;
827
axiom_data_source_t *data_source = NULL;
828
axutil_stream_t *stream = NULL;
832
AXIS2_ENV_CHECK(env, NULL);
833
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, NULL);
836
current_node = parent;
837
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
840
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
844
if(!parent_tag_closed)
847
string_to_stream = ">";
848
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
853
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
855
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
856
sprintf(p_prefix, "n%d", (*next_ns_index)++);
857
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
859
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
860
"http://eucalyptus.ucsb.edu/",
865
if (!_ncDescribeInstancesType->is_valid_correlationId)
868
/* no need to complain for minoccurs=0 element */
874
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
875
(4 + axutil_strlen(p_prefix) +
876
axutil_strlen("correlationId")));
878
/* axutil_strlen("<:>") + 1 = 4 */
879
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
880
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
881
/* axutil_strlen("</:>") + 1 = 5 */
889
* parsing correlationId element
894
sprintf(start_input_str, "<%s%scorrelationId>",
895
p_prefix?p_prefix:"",
896
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
898
start_input_str_len = axutil_strlen(start_input_str);
899
sprintf(end_input_str, "</%s%scorrelationId>",
900
p_prefix?p_prefix:"",
901
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
902
end_input_str_len = axutil_strlen(end_input_str);
904
text_value_1 = _ncDescribeInstancesType->property_correlationId;
906
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
909
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
910
if (text_value_1_temp)
912
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
913
AXIS2_FREE(env->allocator, text_value_1_temp);
917
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
920
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
923
AXIS2_FREE(env->allocator,start_input_str);
924
AXIS2_FREE(env->allocator,end_input_str);
928
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
930
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
931
sprintf(p_prefix, "n%d", (*next_ns_index)++);
932
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
934
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
935
"http://eucalyptus.ucsb.edu/",
940
if (!_ncDescribeInstancesType->is_valid_userId)
943
/* no need to complain for minoccurs=0 element */
949
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
950
(4 + axutil_strlen(p_prefix) +
951
axutil_strlen("userId")));
953
/* axutil_strlen("<:>") + 1 = 4 */
954
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
955
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
956
/* axutil_strlen("</:>") + 1 = 5 */
964
* parsing userId element
969
sprintf(start_input_str, "<%s%suserId>",
970
p_prefix?p_prefix:"",
971
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
973
start_input_str_len = axutil_strlen(start_input_str);
974
sprintf(end_input_str, "</%s%suserId>",
975
p_prefix?p_prefix:"",
976
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
977
end_input_str_len = axutil_strlen(end_input_str);
979
text_value_2 = _ncDescribeInstancesType->property_userId;
981
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
984
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
985
if (text_value_2_temp)
987
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
988
AXIS2_FREE(env->allocator, text_value_2_temp);
992
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
995
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
998
AXIS2_FREE(env->allocator,start_input_str);
999
AXIS2_FREE(env->allocator,end_input_str);
1003
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1005
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1006
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1007
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1009
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1010
"http://eucalyptus.ucsb.edu/",
1015
if (!_ncDescribeInstancesType->is_valid_return)
1018
/* no need to complain for minoccurs=0 element */
1024
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1025
(4 + axutil_strlen(p_prefix) +
1026
axutil_strlen("return")));
1028
/* axutil_strlen("<:>") + 1 = 4 */
1029
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1030
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1031
/* axutil_strlen("</:>") + 1 = 5 */
1039
* parsing return element
1044
sprintf(start_input_str, "<%s%sreturn>",
1045
p_prefix?p_prefix:"",
1046
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1048
start_input_str_len = axutil_strlen(start_input_str);
1049
sprintf(end_input_str, "</%s%sreturn>",
1050
p_prefix?p_prefix:"",
1051
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1052
end_input_str_len = axutil_strlen(end_input_str);
1054
strcpy(text_value_3, (_ncDescribeInstancesType->property_return)?"true":"false");
1056
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1058
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1060
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1063
AXIS2_FREE(env->allocator,start_input_str);
1064
AXIS2_FREE(env->allocator,end_input_str);
1068
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1070
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1071
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1072
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1074
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1075
"http://eucalyptus.ucsb.edu/",
1080
if (!_ncDescribeInstancesType->is_valid_statusMessage)
1083
/* no need to complain for minoccurs=0 element */
1089
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1090
(4 + axutil_strlen(p_prefix) +
1091
axutil_strlen("statusMessage")));
1093
/* axutil_strlen("<:>") + 1 = 4 */
1094
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1095
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1096
/* axutil_strlen("</:>") + 1 = 5 */
1104
* parsing statusMessage element
1109
sprintf(start_input_str, "<%s%sstatusMessage>",
1110
p_prefix?p_prefix:"",
1111
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1113
start_input_str_len = axutil_strlen(start_input_str);
1114
sprintf(end_input_str, "</%s%sstatusMessage>",
1115
p_prefix?p_prefix:"",
1116
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1117
end_input_str_len = axutil_strlen(end_input_str);
1119
sprintf (text_value_4, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeInstancesType->property_statusMessage);
1121
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1123
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1125
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1128
AXIS2_FREE(env->allocator,start_input_str);
1129
AXIS2_FREE(env->allocator,end_input_str);
1133
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1135
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1136
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1137
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1139
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1140
"http://eucalyptus.ucsb.edu/",
1145
if (!_ncDescribeInstancesType->is_valid_instanceIds)
1148
/* no need to complain for minoccurs=0 element */
1154
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1155
(4 + axutil_strlen(p_prefix) +
1156
axutil_strlen("instanceIds")));
1158
/* axutil_strlen("<:>") + 1 = 4 */
1159
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1160
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceIds")));
1161
/* axutil_strlen("</:>") + 1 = 5 */
1168
* Parsing instanceIds array
1170
if (_ncDescribeInstancesType->property_instanceIds != NULL)
1173
sprintf(start_input_str, "<%s%sinstanceIds>",
1174
p_prefix?p_prefix:"",
1175
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1177
start_input_str_len = axutil_strlen(start_input_str);
1179
sprintf(end_input_str, "</%s%sinstanceIds>",
1180
p_prefix?p_prefix:"",
1181
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1182
end_input_str_len = axutil_strlen(end_input_str);
1184
count = axutil_array_list_size(_ncDescribeInstancesType->property_instanceIds, env);
1185
for(i = 0; i < count; i ++)
1187
element = axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i);
1196
* parsing instanceIds element
1201
text_value_5 = (axis2_char_t*)element;
1203
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1206
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1207
if (text_value_5_temp)
1209
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1210
AXIS2_FREE(env->allocator, text_value_5_temp);
1214
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1217
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1223
AXIS2_FREE(env->allocator,start_input_str);
1224
AXIS2_FREE(env->allocator,end_input_str);
1236
* getter for correlationId.
1238
axis2_char_t* AXIS2_CALL
1239
adb_ncDescribeInstancesType_get_correlationId(
1240
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1241
const axutil_env_t *env)
1244
AXIS2_ENV_CHECK(env, NULL);
1245
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, NULL);
1248
return _ncDescribeInstancesType->property_correlationId;
1252
* setter for correlationId
1254
axis2_status_t AXIS2_CALL
1255
adb_ncDescribeInstancesType_set_correlationId(
1256
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1257
const axutil_env_t *env,
1258
const axis2_char_t* arg_correlationId)
1262
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1263
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1265
if(_ncDescribeInstancesType->is_valid_correlationId &&
1266
arg_correlationId == _ncDescribeInstancesType->property_correlationId)
1269
return AXIS2_SUCCESS;
1272
adb_ncDescribeInstancesType_reset_correlationId(_ncDescribeInstancesType, env);
1275
if(NULL == arg_correlationId)
1277
/* We are already done */
1278
return AXIS2_SUCCESS;
1280
_ncDescribeInstancesType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1281
if(NULL == _ncDescribeInstancesType->property_correlationId)
1283
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1284
return AXIS2_FAILURE;
1286
_ncDescribeInstancesType->is_valid_correlationId = AXIS2_TRUE;
1288
return AXIS2_SUCCESS;
1294
* resetter for correlationId
1296
axis2_status_t AXIS2_CALL
1297
adb_ncDescribeInstancesType_reset_correlationId(
1298
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1299
const axutil_env_t *env)
1303
void *element = NULL;
1305
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1306
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1312
if(_ncDescribeInstancesType->property_correlationId != NULL)
1316
AXIS2_FREE(env-> allocator, _ncDescribeInstancesType->property_correlationId);
1317
_ncDescribeInstancesType->property_correlationId = NULL;
1322
_ncDescribeInstancesType->is_valid_correlationId = AXIS2_FALSE;
1323
return AXIS2_SUCCESS;
1327
* Check whether correlationId is nill
1329
axis2_bool_t AXIS2_CALL
1330
adb_ncDescribeInstancesType_is_correlationId_nil(
1331
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1332
const axutil_env_t *env)
1334
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1335
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_TRUE);
1337
return !_ncDescribeInstancesType->is_valid_correlationId;
1341
* Set correlationId to nill (currently the same as reset)
1343
axis2_status_t AXIS2_CALL
1344
adb_ncDescribeInstancesType_set_correlationId_nil(
1345
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1346
const axutil_env_t *env)
1348
return adb_ncDescribeInstancesType_reset_correlationId(_ncDescribeInstancesType, env);
1354
* getter for userId.
1356
axis2_char_t* AXIS2_CALL
1357
adb_ncDescribeInstancesType_get_userId(
1358
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1359
const axutil_env_t *env)
1362
AXIS2_ENV_CHECK(env, NULL);
1363
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, NULL);
1366
return _ncDescribeInstancesType->property_userId;
1372
axis2_status_t AXIS2_CALL
1373
adb_ncDescribeInstancesType_set_userId(
1374
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1375
const axutil_env_t *env,
1376
const axis2_char_t* arg_userId)
1380
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1381
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1383
if(_ncDescribeInstancesType->is_valid_userId &&
1384
arg_userId == _ncDescribeInstancesType->property_userId)
1387
return AXIS2_SUCCESS;
1390
adb_ncDescribeInstancesType_reset_userId(_ncDescribeInstancesType, env);
1393
if(NULL == arg_userId)
1395
/* We are already done */
1396
return AXIS2_SUCCESS;
1398
_ncDescribeInstancesType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1399
if(NULL == _ncDescribeInstancesType->property_userId)
1401
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1402
return AXIS2_FAILURE;
1404
_ncDescribeInstancesType->is_valid_userId = AXIS2_TRUE;
1406
return AXIS2_SUCCESS;
1412
* resetter for userId
1414
axis2_status_t AXIS2_CALL
1415
adb_ncDescribeInstancesType_reset_userId(
1416
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1417
const axutil_env_t *env)
1421
void *element = NULL;
1423
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1424
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1430
if(_ncDescribeInstancesType->property_userId != NULL)
1434
AXIS2_FREE(env-> allocator, _ncDescribeInstancesType->property_userId);
1435
_ncDescribeInstancesType->property_userId = NULL;
1440
_ncDescribeInstancesType->is_valid_userId = AXIS2_FALSE;
1441
return AXIS2_SUCCESS;
1445
* Check whether userId is nill
1447
axis2_bool_t AXIS2_CALL
1448
adb_ncDescribeInstancesType_is_userId_nil(
1449
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1450
const axutil_env_t *env)
1452
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1453
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_TRUE);
1455
return !_ncDescribeInstancesType->is_valid_userId;
1459
* Set userId to nill (currently the same as reset)
1461
axis2_status_t AXIS2_CALL
1462
adb_ncDescribeInstancesType_set_userId_nil(
1463
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1464
const axutil_env_t *env)
1466
return adb_ncDescribeInstancesType_reset_userId(_ncDescribeInstancesType, env);
1472
* getter for return.
1474
axis2_bool_t AXIS2_CALL
1475
adb_ncDescribeInstancesType_get_return(
1476
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1477
const axutil_env_t *env)
1480
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1481
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, (axis2_bool_t)0);
1484
return _ncDescribeInstancesType->property_return;
1490
axis2_status_t AXIS2_CALL
1491
adb_ncDescribeInstancesType_set_return(
1492
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1493
const axutil_env_t *env,
1494
axis2_bool_t arg_return)
1498
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1499
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1501
if(_ncDescribeInstancesType->is_valid_return &&
1502
arg_return == _ncDescribeInstancesType->property_return)
1505
return AXIS2_SUCCESS;
1508
adb_ncDescribeInstancesType_reset_return(_ncDescribeInstancesType, env);
1510
_ncDescribeInstancesType->property_return = arg_return;
1511
_ncDescribeInstancesType->is_valid_return = AXIS2_TRUE;
1513
return AXIS2_SUCCESS;
1519
* resetter for return
1521
axis2_status_t AXIS2_CALL
1522
adb_ncDescribeInstancesType_reset_return(
1523
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1524
const axutil_env_t *env)
1528
void *element = NULL;
1530
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1531
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1534
_ncDescribeInstancesType->is_valid_return = AXIS2_FALSE;
1535
return AXIS2_SUCCESS;
1539
* Check whether return is nill
1541
axis2_bool_t AXIS2_CALL
1542
adb_ncDescribeInstancesType_is_return_nil(
1543
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1544
const axutil_env_t *env)
1546
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1547
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_TRUE);
1549
return !_ncDescribeInstancesType->is_valid_return;
1553
* Set return to nill (currently the same as reset)
1555
axis2_status_t AXIS2_CALL
1556
adb_ncDescribeInstancesType_set_return_nil(
1557
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1558
const axutil_env_t *env)
1560
return adb_ncDescribeInstancesType_reset_return(_ncDescribeInstancesType, env);
1566
* getter for statusMessage.
1569
adb_ncDescribeInstancesType_get_statusMessage(
1570
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1571
const axutil_env_t *env)
1574
AXIS2_ENV_CHECK(env, (int)0);
1575
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, (int)0);
1578
return _ncDescribeInstancesType->property_statusMessage;
1582
* setter for statusMessage
1584
axis2_status_t AXIS2_CALL
1585
adb_ncDescribeInstancesType_set_statusMessage(
1586
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1587
const axutil_env_t *env,
1588
const int arg_statusMessage)
1592
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1593
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1595
if(_ncDescribeInstancesType->is_valid_statusMessage &&
1596
arg_statusMessage == _ncDescribeInstancesType->property_statusMessage)
1599
return AXIS2_SUCCESS;
1602
adb_ncDescribeInstancesType_reset_statusMessage(_ncDescribeInstancesType, env);
1604
_ncDescribeInstancesType->property_statusMessage = arg_statusMessage;
1605
_ncDescribeInstancesType->is_valid_statusMessage = AXIS2_TRUE;
1607
return AXIS2_SUCCESS;
1613
* resetter for statusMessage
1615
axis2_status_t AXIS2_CALL
1616
adb_ncDescribeInstancesType_reset_statusMessage(
1617
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1618
const axutil_env_t *env)
1622
void *element = NULL;
1624
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1625
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1628
_ncDescribeInstancesType->is_valid_statusMessage = AXIS2_FALSE;
1629
return AXIS2_SUCCESS;
1633
* Check whether statusMessage is nill
1635
axis2_bool_t AXIS2_CALL
1636
adb_ncDescribeInstancesType_is_statusMessage_nil(
1637
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1638
const axutil_env_t *env)
1640
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1641
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_TRUE);
1643
return !_ncDescribeInstancesType->is_valid_statusMessage;
1647
* Set statusMessage to nill (currently the same as reset)
1649
axis2_status_t AXIS2_CALL
1650
adb_ncDescribeInstancesType_set_statusMessage_nil(
1651
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1652
const axutil_env_t *env)
1654
return adb_ncDescribeInstancesType_reset_statusMessage(_ncDescribeInstancesType, env);
1660
* getter for instanceIds.
1662
axutil_array_list_t* AXIS2_CALL
1663
adb_ncDescribeInstancesType_get_instanceIds(
1664
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1665
const axutil_env_t *env)
1668
AXIS2_ENV_CHECK(env, NULL);
1669
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, NULL);
1672
return _ncDescribeInstancesType->property_instanceIds;
1676
* setter for instanceIds
1678
axis2_status_t AXIS2_CALL
1679
adb_ncDescribeInstancesType_set_instanceIds(
1680
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1681
const axutil_env_t *env,
1682
axutil_array_list_t* arg_instanceIds)
1687
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1690
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1691
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1693
if(_ncDescribeInstancesType->is_valid_instanceIds &&
1694
arg_instanceIds == _ncDescribeInstancesType->property_instanceIds)
1697
return AXIS2_SUCCESS;
1701
size = axutil_array_list_size(arg_instanceIds, env);
1705
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceIds has less than minOccurs(0)");
1706
return AXIS2_FAILURE;
1708
for(i = 0; i < size; i ++ )
1710
if(NULL != axutil_array_list_get(arg_instanceIds, env, i))
1712
non_nil_exists = AXIS2_TRUE;
1717
adb_ncDescribeInstancesType_reset_instanceIds(_ncDescribeInstancesType, env);
1720
if(NULL == arg_instanceIds)
1722
/* We are already done */
1723
return AXIS2_SUCCESS;
1725
_ncDescribeInstancesType->property_instanceIds = arg_instanceIds;
1728
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1732
return AXIS2_SUCCESS;
1737
* Get ith element of instanceIds.
1739
axis2_char_t* AXIS2_CALL
1740
adb_ncDescribeInstancesType_get_instanceIds_at(
1741
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1742
const axutil_env_t *env, int i)
1744
axis2_char_t* ret_val;
1747
AXIS2_ENV_CHECK(env, NULL);
1748
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, NULL);
1751
if(_ncDescribeInstancesType->property_instanceIds == NULL)
1753
return (axis2_char_t*)0;
1755
ret_val = (axis2_char_t*)axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i);
1762
* Set the ith element of instanceIds.
1764
axis2_status_t AXIS2_CALL
1765
adb_ncDescribeInstancesType_set_instanceIds_at(
1766
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1767
const axutil_env_t *env, int i,
1768
const axis2_char_t* arg_instanceIds)
1770
void *element = NULL;
1774
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1778
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1779
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1781
if( _ncDescribeInstancesType->is_valid_instanceIds &&
1782
_ncDescribeInstancesType->property_instanceIds &&
1784
arg_instanceIds == (axis2_char_t*)axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i))
1788
return AXIS2_SUCCESS;
1792
if(NULL == arg_instanceIds)
1794
if(_ncDescribeInstancesType->property_instanceIds != NULL)
1796
size = axutil_array_list_size(_ncDescribeInstancesType->property_instanceIds, env);
1797
for(j = 0, k = 0; j < size; j ++ )
1799
if(i == j) continue;
1800
if(NULL != axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i))
1803
non_nil_exists = AXIS2_TRUE;
1814
non_nil_exists = AXIS2_TRUE;
1819
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)");
1820
return AXIS2_FAILURE;
1823
if(_ncDescribeInstancesType->property_instanceIds == NULL)
1825
_ncDescribeInstancesType->property_instanceIds = axutil_array_list_create(env, 10);
1828
/* check whether there already exist an element */
1829
element = axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i);
1835
/* This is an unknown type or a primitive. Please free this manually*/
1843
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_FALSE;
1844
axutil_array_list_set(_ncDescribeInstancesType->property_instanceIds , env, i, NULL);
1846
return AXIS2_SUCCESS;
1849
axutil_array_list_set(_ncDescribeInstancesType->property_instanceIds , env, i, axutil_strdup(env, arg_instanceIds));
1850
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1852
return AXIS2_SUCCESS;
1856
* Add to instanceIds.
1858
axis2_status_t AXIS2_CALL
1859
adb_ncDescribeInstancesType_add_instanceIds(
1860
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1861
const axutil_env_t *env,
1862
const axis2_char_t* arg_instanceIds)
1866
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1867
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1870
if(NULL == arg_instanceIds)
1873
return AXIS2_SUCCESS;
1878
if(_ncDescribeInstancesType->property_instanceIds == NULL)
1880
_ncDescribeInstancesType->property_instanceIds = axutil_array_list_create(env, 10);
1882
if(_ncDescribeInstancesType->property_instanceIds == NULL)
1884
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for instanceIds");
1885
return AXIS2_FAILURE;
1889
axutil_array_list_add(_ncDescribeInstancesType->property_instanceIds , env, axutil_strdup(env, arg_instanceIds));
1890
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1891
return AXIS2_SUCCESS;
1895
* Get the size of the instanceIds array.
1898
adb_ncDescribeInstancesType_sizeof_instanceIds(
1899
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1900
const axutil_env_t *env)
1902
AXIS2_ENV_CHECK(env, -1);
1903
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, -1);
1904
if(_ncDescribeInstancesType->property_instanceIds == NULL)
1908
return axutil_array_list_size(_ncDescribeInstancesType->property_instanceIds, env);
1912
* remove the ith element, same as set_nil_at.
1914
axis2_status_t AXIS2_CALL
1915
adb_ncDescribeInstancesType_remove_instanceIds_at(
1916
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1917
const axutil_env_t *env, int i)
1919
return adb_ncDescribeInstancesType_set_instanceIds_nil_at(_ncDescribeInstancesType, env, i);
1925
* resetter for instanceIds
1927
axis2_status_t AXIS2_CALL
1928
adb_ncDescribeInstancesType_reset_instanceIds(
1929
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1930
const axutil_env_t *env)
1934
void *element = NULL;
1936
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1937
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
1941
if (_ncDescribeInstancesType->property_instanceIds != NULL)
1943
count = axutil_array_list_size(_ncDescribeInstancesType->property_instanceIds, env);
1944
for(i = 0; i < count; i ++)
1946
element = axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i);
1954
AXIS2_FREE(env-> allocator, (axis2_char_t*)element);
1962
axutil_array_list_free(_ncDescribeInstancesType->property_instanceIds, env);
1964
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_FALSE;
1965
return AXIS2_SUCCESS;
1969
* Check whether instanceIds is nill
1971
axis2_bool_t AXIS2_CALL
1972
adb_ncDescribeInstancesType_is_instanceIds_nil(
1973
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1974
const axutil_env_t *env)
1976
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1977
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_TRUE);
1979
return !_ncDescribeInstancesType->is_valid_instanceIds;
1983
* Set instanceIds to nill (currently the same as reset)
1985
axis2_status_t AXIS2_CALL
1986
adb_ncDescribeInstancesType_set_instanceIds_nil(
1987
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
1988
const axutil_env_t *env)
1990
return adb_ncDescribeInstancesType_reset_instanceIds(_ncDescribeInstancesType, env);
1995
* Check whether instanceIds is nill at i
1997
axis2_bool_t AXIS2_CALL
1998
adb_ncDescribeInstancesType_is_instanceIds_nil_at(
1999
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
2000
const axutil_env_t *env, int i)
2002
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2003
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_TRUE);
2005
return (_ncDescribeInstancesType->is_valid_instanceIds == AXIS2_FALSE ||
2006
NULL == _ncDescribeInstancesType->property_instanceIds ||
2007
NULL == axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i));
2011
* Set instanceIds to nill at i
2013
axis2_status_t AXIS2_CALL
2014
adb_ncDescribeInstancesType_set_instanceIds_nil_at(
2015
adb_ncDescribeInstancesType_t* _ncDescribeInstancesType,
2016
const axutil_env_t *env, int i)
2018
void *element = NULL;
2021
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2025
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2026
AXIS2_PARAM_CHECK(env->error, _ncDescribeInstancesType, AXIS2_FAILURE);
2028
if(_ncDescribeInstancesType->property_instanceIds == NULL ||
2029
_ncDescribeInstancesType->is_valid_instanceIds == AXIS2_FALSE)
2032
non_nil_exists = AXIS2_FALSE;
2036
size = axutil_array_list_size(_ncDescribeInstancesType->property_instanceIds, env);
2037
for(j = 0, k = 0; j < size; j ++ )
2039
if(i == j) continue;
2040
if(NULL != axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i))
2043
non_nil_exists = AXIS2_TRUE;
2055
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)");
2056
return AXIS2_FAILURE;
2059
if(_ncDescribeInstancesType->property_instanceIds == NULL)
2061
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2063
return AXIS2_SUCCESS;
2066
/* check whether there already exist an element */
2067
element = axutil_array_list_get(_ncDescribeInstancesType->property_instanceIds, env, i);
2073
/* This is an unknown type or a primitive. Please free this manually*/
2081
_ncDescribeInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2082
axutil_array_list_set(_ncDescribeInstancesType->property_instanceIds , env, i, NULL);
2083
return AXIS2_SUCCESS;
2088
axutil_array_list_set(_ncDescribeInstancesType->property_instanceIds , env, i, NULL);
2090
return AXIS2_SUCCESS;