4
* adb_describeInstancesResponseType.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_describeInstancesResponseType.h"
13
* This type was generated from the piece of schema that had
14
* name = describeInstancesResponseType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_describeInstancesResponseType
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_instances;
50
axis2_bool_t is_valid_instances;
57
/************************* Private Function prototypes ********************************/
60
axis2_status_t AXIS2_CALL
61
adb_describeInstancesResponseType_set_correlationId_nil(
62
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
63
const axutil_env_t *env);
66
axis2_status_t AXIS2_CALL
67
adb_describeInstancesResponseType_set_userId_nil(
68
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_describeInstancesResponseType_set_return_nil(
74
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
75
const axutil_env_t *env);
79
/************************* Function Implmentations ********************************/
80
adb_describeInstancesResponseType_t* AXIS2_CALL
81
adb_describeInstancesResponseType_create(
82
const axutil_env_t *env)
84
adb_describeInstancesResponseType_t *_describeInstancesResponseType = NULL;
86
AXIS2_ENV_CHECK(env, NULL);
88
_describeInstancesResponseType = (adb_describeInstancesResponseType_t *) AXIS2_MALLOC(env->
89
allocator, sizeof(adb_describeInstancesResponseType_t));
91
if(NULL == _describeInstancesResponseType)
93
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
97
memset(_describeInstancesResponseType, 0, sizeof(adb_describeInstancesResponseType_t));
99
_describeInstancesResponseType->property_correlationId = NULL;
100
_describeInstancesResponseType->is_valid_correlationId = AXIS2_FALSE;
101
_describeInstancesResponseType->property_userId = NULL;
102
_describeInstancesResponseType->is_valid_userId = AXIS2_FALSE;
103
_describeInstancesResponseType->property_statusMessage = NULL;
104
_describeInstancesResponseType->is_valid_statusMessage = AXIS2_FALSE;
105
_describeInstancesResponseType->is_valid_return = AXIS2_FALSE;
106
_describeInstancesResponseType->property_instances = NULL;
107
_describeInstancesResponseType->is_valid_instances = AXIS2_FALSE;
110
return _describeInstancesResponseType;
113
axis2_status_t AXIS2_CALL
114
adb_describeInstancesResponseType_free (
115
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
116
const axutil_env_t *env)
121
void *element = NULL;
124
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
125
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
127
adb_describeInstancesResponseType_reset_correlationId(_describeInstancesResponseType, env);
128
adb_describeInstancesResponseType_reset_userId(_describeInstancesResponseType, env);
129
adb_describeInstancesResponseType_reset_statusMessage(_describeInstancesResponseType, env);
130
adb_describeInstancesResponseType_reset_return(_describeInstancesResponseType, env);
131
adb_describeInstancesResponseType_reset_instances(_describeInstancesResponseType, env);
134
if(_describeInstancesResponseType)
136
AXIS2_FREE(env->allocator, _describeInstancesResponseType);
137
_describeInstancesResponseType = NULL;
139
return AXIS2_SUCCESS;
145
axis2_status_t AXIS2_CALL
146
adb_describeInstancesResponseType_deserialize(
147
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
148
const axutil_env_t *env,
149
axiom_node_t **dp_parent,
150
axis2_bool_t *dp_is_early_node_valid,
151
axis2_bool_t dont_care_minoccurs)
153
axiom_node_t *parent = *dp_parent;
155
axis2_status_t status = AXIS2_SUCCESS;
157
void *element = NULL;
159
axis2_char_t* text_value = NULL;
160
axutil_qname_t *qname = NULL;
163
axutil_array_list_t *arr_list = NULL;
165
int sequence_broken = 0;
166
axiom_node_t *tmp_node = NULL;
168
axutil_qname_t *element_qname = NULL;
170
axiom_node_t *first_node = NULL;
171
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
172
axiom_node_t *current_node = NULL;
173
axiom_element_t *current_element = NULL;
175
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
176
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
180
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
182
parent = axiom_node_get_next_sibling(parent, env);
186
/* This should be checked before everything */
187
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
188
"Failed in building adb object for describeInstancesResponseType : "
189
"NULL elemenet can not be passed to deserialize");
190
return AXIS2_FAILURE;
194
first_node = axiom_node_get_first_child(parent, env);
200
* building correlationId element
205
current_node = first_node;
206
is_early_node_valid = AXIS2_FALSE;
209
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
211
current_node = axiom_node_get_next_sibling(current_node, env);
213
if(current_node != NULL)
215
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
216
qname = axiom_element_get_qname(current_element, env, current_node);
219
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
223
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
225
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
227
is_early_node_valid = AXIS2_TRUE;
231
text_value = axiom_element_get_text(current_element, env, current_node);
232
if(text_value != NULL)
234
status = adb_describeInstancesResponseType_set_correlationId(_describeInstancesResponseType, env,
241
* axis2_qname_t *qname = NULL;
242
* axiom_attribute_t *the_attri = NULL;
244
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
245
* the_attri = axiom_element_get_attribute(current_element, env, qname);
247
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
249
axiom_attribute_t *the_attri = NULL;
250
axis2_char_t *attrib_text = NULL;
251
axutil_hash_t *attribute_hash = NULL;
253
attribute_hash = axiom_element_get_all_attributes(current_element, env);
258
axutil_hash_index_t *hi;
262
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
264
axutil_hash_this(hi, &key, NULL, &val);
266
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
268
the_attri = (axiom_attribute_t*)val;
276
attrib_text = axiom_attribute_get_value(the_attri, env);
280
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
281
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
284
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
286
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
287
status = AXIS2_FAILURE;
291
/* after all, we found this is a empty string */
292
status = adb_describeInstancesResponseType_set_correlationId(_describeInstancesResponseType, env,
297
if(AXIS2_FAILURE == status)
299
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
302
axutil_qname_free(element_qname, env);
304
return AXIS2_FAILURE;
310
axutil_qname_free(element_qname, env);
311
element_qname = NULL;
317
* building userId element
323
* because elements are ordered this works fine
327
if(current_node != NULL && is_early_node_valid)
329
current_node = axiom_node_get_next_sibling(current_node, env);
332
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
334
current_node = axiom_node_get_next_sibling(current_node, env);
336
if(current_node != NULL)
338
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
339
qname = axiom_element_get_qname(current_element, env, current_node);
343
is_early_node_valid = AXIS2_FALSE;
345
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
349
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
351
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
353
is_early_node_valid = AXIS2_TRUE;
357
text_value = axiom_element_get_text(current_element, env, current_node);
358
if(text_value != NULL)
360
status = adb_describeInstancesResponseType_set_userId(_describeInstancesResponseType, env,
367
* axis2_qname_t *qname = NULL;
368
* axiom_attribute_t *the_attri = NULL;
370
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
371
* the_attri = axiom_element_get_attribute(current_element, env, qname);
373
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
375
axiom_attribute_t *the_attri = NULL;
376
axis2_char_t *attrib_text = NULL;
377
axutil_hash_t *attribute_hash = NULL;
379
attribute_hash = axiom_element_get_all_attributes(current_element, env);
384
axutil_hash_index_t *hi;
388
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
390
axutil_hash_this(hi, &key, NULL, &val);
392
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
394
the_attri = (axiom_attribute_t*)val;
402
attrib_text = axiom_attribute_get_value(the_attri, env);
406
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
407
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
410
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
412
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
413
status = AXIS2_FAILURE;
417
/* after all, we found this is a empty string */
418
status = adb_describeInstancesResponseType_set_userId(_describeInstancesResponseType, env,
423
if(AXIS2_FAILURE == status)
425
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
428
axutil_qname_free(element_qname, env);
430
return AXIS2_FAILURE;
436
axutil_qname_free(element_qname, env);
437
element_qname = NULL;
443
* building statusMessage element
449
* because elements are ordered this works fine
453
if(current_node != NULL && is_early_node_valid)
455
current_node = axiom_node_get_next_sibling(current_node, env);
458
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
460
current_node = axiom_node_get_next_sibling(current_node, env);
462
if(current_node != NULL)
464
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
465
qname = axiom_element_get_qname(current_element, env, current_node);
469
is_early_node_valid = AXIS2_FALSE;
471
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
475
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
477
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
479
is_early_node_valid = AXIS2_TRUE;
483
text_value = axiom_element_get_text(current_element, env, current_node);
484
if(text_value != NULL)
486
status = adb_describeInstancesResponseType_set_statusMessage(_describeInstancesResponseType, env,
490
if(AXIS2_FAILURE == status)
492
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
495
axutil_qname_free(element_qname, env);
497
return AXIS2_FAILURE;
503
axutil_qname_free(element_qname, env);
504
element_qname = NULL;
510
* building return element
516
* because elements are ordered this works fine
520
if(current_node != NULL && is_early_node_valid)
522
current_node = axiom_node_get_next_sibling(current_node, env);
525
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
527
current_node = axiom_node_get_next_sibling(current_node, env);
529
if(current_node != NULL)
531
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
532
qname = axiom_element_get_qname(current_element, env, current_node);
536
is_early_node_valid = AXIS2_FALSE;
538
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
542
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
544
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
546
is_early_node_valid = AXIS2_TRUE;
550
text_value = axiom_element_get_text(current_element, env, current_node);
551
if(text_value != NULL)
553
if (!axutil_strcasecmp(text_value , "true"))
555
status = adb_describeInstancesResponseType_set_return(_describeInstancesResponseType, env,
560
status = adb_describeInstancesResponseType_set_return(_describeInstancesResponseType, env,
567
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
568
status = AXIS2_FAILURE;
571
if(AXIS2_FAILURE == status)
573
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
576
axutil_qname_free(element_qname, env);
578
return AXIS2_FAILURE;
584
axutil_qname_free(element_qname, env);
585
element_qname = NULL;
589
* building instances array
591
arr_list = axutil_array_list_create(env, 10);
596
* building instances element
601
element_qname = axutil_qname_create(env, "instances", "http://eucalyptus.ucsb.edu/", NULL);
604
for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
607
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
609
current_node =axiom_node_get_next_sibling(current_node, env);
610
is_early_node_valid = AXIS2_FALSE;
614
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
615
qname = axiom_element_get_qname(current_element, env, current_node);
617
if (axutil_qname_equals(element_qname, env, qname))
620
is_early_node_valid = AXIS2_TRUE;
623
element = (void*)adb_ccInstanceType_create(env);
625
status = adb_ccInstanceType_deserialize((adb_ccInstanceType_t*)element, env,
626
¤t_node, &is_early_node_valid, AXIS2_FALSE);
628
if(AXIS2_FAILURE == status)
630
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building element instances ");
634
axutil_array_list_add_at(arr_list, env, i, element);
637
if(AXIS2_FAILURE == status)
639
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instances ");
642
axutil_qname_free(element_qname, env);
646
axutil_array_list_free(arr_list, env);
648
return AXIS2_FAILURE;
652
current_node = axiom_node_get_next_sibling(current_node, env);
656
is_early_node_valid = AXIS2_FALSE;
665
/* found element out of order */
666
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instances (@minOccurs = '0') only have %d elements", i);
669
axutil_qname_free(element_qname, env);
673
axutil_array_list_free(arr_list, env);
675
return AXIS2_FAILURE;
679
if(0 == axutil_array_list_size(arr_list,env))
681
axutil_array_list_free(arr_list, env);
685
status = adb_describeInstancesResponseType_set_instances(_describeInstancesResponseType, env,
692
axutil_qname_free(element_qname, env);
693
element_qname = NULL;
699
axis2_bool_t AXIS2_CALL
700
adb_describeInstancesResponseType_is_particle()
709
adb_describeInstancesResponseType_declare_parent_namespaces(
710
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
711
const axutil_env_t *env, axiom_element_t *parent_element,
712
axutil_hash_t *namespaces, int *next_ns_index)
715
/* Here this is an empty function, Nothing to declare */
721
axiom_node_t* AXIS2_CALL
722
adb_describeInstancesResponseType_serialize(
723
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
724
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)
728
axis2_char_t *string_to_stream;
731
axiom_node_t *current_node = NULL;
736
axiom_namespace_t *ns1 = NULL;
738
axis2_char_t *qname_uri = NULL;
739
axis2_char_t *qname_prefix = NULL;
740
axis2_char_t *p_prefix = NULL;
741
axis2_bool_t ns_already_defined;
745
void *element = NULL;
747
axis2_char_t *text_value_1;
748
axis2_char_t *text_value_1_temp;
750
axis2_char_t *text_value_2;
751
axis2_char_t *text_value_2_temp;
753
axis2_char_t *text_value_3;
754
axis2_char_t *text_value_3_temp;
756
axis2_char_t text_value_4[64];
758
axis2_char_t text_value_5[64];
760
axis2_char_t *start_input_str = NULL;
761
axis2_char_t *end_input_str = NULL;
762
unsigned int start_input_str_len = 0;
763
unsigned int end_input_str_len = 0;
766
axiom_data_source_t *data_source = NULL;
767
axutil_stream_t *stream = NULL;
771
AXIS2_ENV_CHECK(env, NULL);
772
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, NULL);
775
current_node = parent;
776
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
779
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
783
if(!parent_tag_closed)
786
string_to_stream = ">";
787
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
792
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
794
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
795
sprintf(p_prefix, "n%d", (*next_ns_index)++);
796
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
798
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
799
"http://eucalyptus.ucsb.edu/",
804
if (!_describeInstancesResponseType->is_valid_correlationId)
807
/* no need to complain for minoccurs=0 element */
813
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
814
(4 + axutil_strlen(p_prefix) +
815
axutil_strlen("correlationId")));
817
/* axutil_strlen("<:>") + 1 = 4 */
818
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
819
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
820
/* axutil_strlen("</:>") + 1 = 5 */
828
* parsing correlationId element
833
sprintf(start_input_str, "<%s%scorrelationId>",
834
p_prefix?p_prefix:"",
835
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
837
start_input_str_len = axutil_strlen(start_input_str);
838
sprintf(end_input_str, "</%s%scorrelationId>",
839
p_prefix?p_prefix:"",
840
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
841
end_input_str_len = axutil_strlen(end_input_str);
843
text_value_1 = _describeInstancesResponseType->property_correlationId;
845
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
848
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
849
if (text_value_1_temp)
851
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
852
AXIS2_FREE(env->allocator, text_value_1_temp);
856
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
859
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
862
AXIS2_FREE(env->allocator,start_input_str);
863
AXIS2_FREE(env->allocator,end_input_str);
867
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
869
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
870
sprintf(p_prefix, "n%d", (*next_ns_index)++);
871
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
873
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
874
"http://eucalyptus.ucsb.edu/",
879
if (!_describeInstancesResponseType->is_valid_userId)
882
/* no need to complain for minoccurs=0 element */
888
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
889
(4 + axutil_strlen(p_prefix) +
890
axutil_strlen("userId")));
892
/* axutil_strlen("<:>") + 1 = 4 */
893
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
894
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
895
/* axutil_strlen("</:>") + 1 = 5 */
903
* parsing userId element
908
sprintf(start_input_str, "<%s%suserId>",
909
p_prefix?p_prefix:"",
910
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
912
start_input_str_len = axutil_strlen(start_input_str);
913
sprintf(end_input_str, "</%s%suserId>",
914
p_prefix?p_prefix:"",
915
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
916
end_input_str_len = axutil_strlen(end_input_str);
918
text_value_2 = _describeInstancesResponseType->property_userId;
920
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
923
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
924
if (text_value_2_temp)
926
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
927
AXIS2_FREE(env->allocator, text_value_2_temp);
931
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
934
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
937
AXIS2_FREE(env->allocator,start_input_str);
938
AXIS2_FREE(env->allocator,end_input_str);
942
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
944
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
945
sprintf(p_prefix, "n%d", (*next_ns_index)++);
946
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
948
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
949
"http://eucalyptus.ucsb.edu/",
954
if (!_describeInstancesResponseType->is_valid_statusMessage)
957
/* no need to complain for minoccurs=0 element */
963
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
964
(4 + axutil_strlen(p_prefix) +
965
axutil_strlen("statusMessage")));
967
/* axutil_strlen("<:>") + 1 = 4 */
968
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
969
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
970
/* axutil_strlen("</:>") + 1 = 5 */
978
* parsing statusMessage element
983
sprintf(start_input_str, "<%s%sstatusMessage>",
984
p_prefix?p_prefix:"",
985
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
987
start_input_str_len = axutil_strlen(start_input_str);
988
sprintf(end_input_str, "</%s%sstatusMessage>",
989
p_prefix?p_prefix:"",
990
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
991
end_input_str_len = axutil_strlen(end_input_str);
993
text_value_3 = _describeInstancesResponseType->property_statusMessage;
995
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
998
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
999
if (text_value_3_temp)
1001
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1002
AXIS2_FREE(env->allocator, text_value_3_temp);
1006
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1009
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1012
AXIS2_FREE(env->allocator,start_input_str);
1013
AXIS2_FREE(env->allocator,end_input_str);
1017
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1019
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1020
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1021
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1023
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1024
"http://eucalyptus.ucsb.edu/",
1029
if (!_describeInstancesResponseType->is_valid_return)
1032
/* no need to complain for minoccurs=0 element */
1038
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1039
(4 + axutil_strlen(p_prefix) +
1040
axutil_strlen("return")));
1042
/* axutil_strlen("<:>") + 1 = 4 */
1043
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1044
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1045
/* axutil_strlen("</:>") + 1 = 5 */
1053
* parsing return element
1058
sprintf(start_input_str, "<%s%sreturn>",
1059
p_prefix?p_prefix:"",
1060
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1062
start_input_str_len = axutil_strlen(start_input_str);
1063
sprintf(end_input_str, "</%s%sreturn>",
1064
p_prefix?p_prefix:"",
1065
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1066
end_input_str_len = axutil_strlen(end_input_str);
1068
strcpy(text_value_4, (_describeInstancesResponseType->property_return)?"true":"false");
1070
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1072
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1074
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1077
AXIS2_FREE(env->allocator,start_input_str);
1078
AXIS2_FREE(env->allocator,end_input_str);
1082
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1084
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1085
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1086
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1088
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1089
"http://eucalyptus.ucsb.edu/",
1094
if (!_describeInstancesResponseType->is_valid_instances)
1097
/* no need to complain for minoccurs=0 element */
1103
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1104
(4 + axutil_strlen(p_prefix) +
1105
axutil_strlen("instances")));
1107
/* axutil_strlen("<:>") + 1 = 4 */
1108
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1109
(5 + axutil_strlen(p_prefix) + axutil_strlen("instances")));
1110
/* axutil_strlen("</:>") + 1 = 5 */
1117
* Parsing instances array
1119
if (_describeInstancesResponseType->property_instances != NULL)
1123
sprintf(start_input_str, "<%s%sinstances",
1124
p_prefix?p_prefix:"",
1125
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1127
start_input_str_len = axutil_strlen(start_input_str);
1129
sprintf(end_input_str, "</%s%sinstances>",
1130
p_prefix?p_prefix:"",
1131
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1132
end_input_str_len = axutil_strlen(end_input_str);
1134
count = axutil_array_list_size(_describeInstancesResponseType->property_instances, env);
1135
for(i = 0; i < count; i ++)
1137
element = axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i);
1146
* parsing instances element
1151
if(!adb_ccInstanceType_is_particle())
1153
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1156
adb_ccInstanceType_serialize((adb_ccInstanceType_t*)element,
1157
env, current_node, parent_element,
1158
adb_ccInstanceType_is_particle() || AXIS2_FALSE, namespaces, next_ns_index);
1160
if(!adb_ccInstanceType_is_particle())
1162
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1169
AXIS2_FREE(env->allocator,start_input_str);
1170
AXIS2_FREE(env->allocator,end_input_str);
1182
* getter for correlationId.
1184
axis2_char_t* AXIS2_CALL
1185
adb_describeInstancesResponseType_get_correlationId(
1186
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1187
const axutil_env_t *env)
1190
AXIS2_ENV_CHECK(env, NULL);
1191
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, NULL);
1194
return _describeInstancesResponseType->property_correlationId;
1198
* setter for correlationId
1200
axis2_status_t AXIS2_CALL
1201
adb_describeInstancesResponseType_set_correlationId(
1202
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1203
const axutil_env_t *env,
1204
const axis2_char_t* arg_correlationId)
1208
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1209
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1211
if(_describeInstancesResponseType->is_valid_correlationId &&
1212
arg_correlationId == _describeInstancesResponseType->property_correlationId)
1215
return AXIS2_SUCCESS;
1218
adb_describeInstancesResponseType_reset_correlationId(_describeInstancesResponseType, env);
1221
if(NULL == arg_correlationId)
1223
/* We are already done */
1224
return AXIS2_SUCCESS;
1226
_describeInstancesResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1227
if(NULL == _describeInstancesResponseType->property_correlationId)
1229
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1230
return AXIS2_FAILURE;
1232
_describeInstancesResponseType->is_valid_correlationId = AXIS2_TRUE;
1234
return AXIS2_SUCCESS;
1240
* resetter for correlationId
1242
axis2_status_t AXIS2_CALL
1243
adb_describeInstancesResponseType_reset_correlationId(
1244
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1245
const axutil_env_t *env)
1249
void *element = NULL;
1251
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1252
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1258
if(_describeInstancesResponseType->property_correlationId != NULL)
1262
AXIS2_FREE(env-> allocator, _describeInstancesResponseType->property_correlationId);
1263
_describeInstancesResponseType->property_correlationId = NULL;
1268
_describeInstancesResponseType->is_valid_correlationId = AXIS2_FALSE;
1269
return AXIS2_SUCCESS;
1273
* Check whether correlationId is nill
1275
axis2_bool_t AXIS2_CALL
1276
adb_describeInstancesResponseType_is_correlationId_nil(
1277
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1278
const axutil_env_t *env)
1280
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1281
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_TRUE);
1283
return !_describeInstancesResponseType->is_valid_correlationId;
1287
* Set correlationId to nill (currently the same as reset)
1289
axis2_status_t AXIS2_CALL
1290
adb_describeInstancesResponseType_set_correlationId_nil(
1291
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1292
const axutil_env_t *env)
1294
return adb_describeInstancesResponseType_reset_correlationId(_describeInstancesResponseType, env);
1300
* getter for userId.
1302
axis2_char_t* AXIS2_CALL
1303
adb_describeInstancesResponseType_get_userId(
1304
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1305
const axutil_env_t *env)
1308
AXIS2_ENV_CHECK(env, NULL);
1309
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, NULL);
1312
return _describeInstancesResponseType->property_userId;
1318
axis2_status_t AXIS2_CALL
1319
adb_describeInstancesResponseType_set_userId(
1320
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1321
const axutil_env_t *env,
1322
const axis2_char_t* arg_userId)
1326
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1327
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1329
if(_describeInstancesResponseType->is_valid_userId &&
1330
arg_userId == _describeInstancesResponseType->property_userId)
1333
return AXIS2_SUCCESS;
1336
adb_describeInstancesResponseType_reset_userId(_describeInstancesResponseType, env);
1339
if(NULL == arg_userId)
1341
/* We are already done */
1342
return AXIS2_SUCCESS;
1344
_describeInstancesResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1345
if(NULL == _describeInstancesResponseType->property_userId)
1347
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1348
return AXIS2_FAILURE;
1350
_describeInstancesResponseType->is_valid_userId = AXIS2_TRUE;
1352
return AXIS2_SUCCESS;
1358
* resetter for userId
1360
axis2_status_t AXIS2_CALL
1361
adb_describeInstancesResponseType_reset_userId(
1362
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1363
const axutil_env_t *env)
1367
void *element = NULL;
1369
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1370
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1376
if(_describeInstancesResponseType->property_userId != NULL)
1380
AXIS2_FREE(env-> allocator, _describeInstancesResponseType->property_userId);
1381
_describeInstancesResponseType->property_userId = NULL;
1386
_describeInstancesResponseType->is_valid_userId = AXIS2_FALSE;
1387
return AXIS2_SUCCESS;
1391
* Check whether userId is nill
1393
axis2_bool_t AXIS2_CALL
1394
adb_describeInstancesResponseType_is_userId_nil(
1395
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1396
const axutil_env_t *env)
1398
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1399
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_TRUE);
1401
return !_describeInstancesResponseType->is_valid_userId;
1405
* Set userId to nill (currently the same as reset)
1407
axis2_status_t AXIS2_CALL
1408
adb_describeInstancesResponseType_set_userId_nil(
1409
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1410
const axutil_env_t *env)
1412
return adb_describeInstancesResponseType_reset_userId(_describeInstancesResponseType, env);
1418
* getter for statusMessage.
1420
axis2_char_t* AXIS2_CALL
1421
adb_describeInstancesResponseType_get_statusMessage(
1422
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1423
const axutil_env_t *env)
1426
AXIS2_ENV_CHECK(env, NULL);
1427
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, NULL);
1430
return _describeInstancesResponseType->property_statusMessage;
1434
* setter for statusMessage
1436
axis2_status_t AXIS2_CALL
1437
adb_describeInstancesResponseType_set_statusMessage(
1438
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1439
const axutil_env_t *env,
1440
const axis2_char_t* arg_statusMessage)
1444
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1445
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1447
if(_describeInstancesResponseType->is_valid_statusMessage &&
1448
arg_statusMessage == _describeInstancesResponseType->property_statusMessage)
1451
return AXIS2_SUCCESS;
1454
adb_describeInstancesResponseType_reset_statusMessage(_describeInstancesResponseType, env);
1457
if(NULL == arg_statusMessage)
1459
/* We are already done */
1460
return AXIS2_SUCCESS;
1462
_describeInstancesResponseType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1463
if(NULL == _describeInstancesResponseType->property_statusMessage)
1465
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1466
return AXIS2_FAILURE;
1468
_describeInstancesResponseType->is_valid_statusMessage = AXIS2_TRUE;
1470
return AXIS2_SUCCESS;
1476
* resetter for statusMessage
1478
axis2_status_t AXIS2_CALL
1479
adb_describeInstancesResponseType_reset_statusMessage(
1480
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1481
const axutil_env_t *env)
1485
void *element = NULL;
1487
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1488
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1494
if(_describeInstancesResponseType->property_statusMessage != NULL)
1498
AXIS2_FREE(env-> allocator, _describeInstancesResponseType->property_statusMessage);
1499
_describeInstancesResponseType->property_statusMessage = NULL;
1504
_describeInstancesResponseType->is_valid_statusMessage = AXIS2_FALSE;
1505
return AXIS2_SUCCESS;
1509
* Check whether statusMessage is nill
1511
axis2_bool_t AXIS2_CALL
1512
adb_describeInstancesResponseType_is_statusMessage_nil(
1513
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1514
const axutil_env_t *env)
1516
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1517
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_TRUE);
1519
return !_describeInstancesResponseType->is_valid_statusMessage;
1523
* Set statusMessage to nill (currently the same as reset)
1525
axis2_status_t AXIS2_CALL
1526
adb_describeInstancesResponseType_set_statusMessage_nil(
1527
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1528
const axutil_env_t *env)
1530
return adb_describeInstancesResponseType_reset_statusMessage(_describeInstancesResponseType, env);
1536
* getter for return.
1538
axis2_bool_t AXIS2_CALL
1539
adb_describeInstancesResponseType_get_return(
1540
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1541
const axutil_env_t *env)
1544
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1545
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, (axis2_bool_t)0);
1548
return _describeInstancesResponseType->property_return;
1554
axis2_status_t AXIS2_CALL
1555
adb_describeInstancesResponseType_set_return(
1556
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1557
const axutil_env_t *env,
1558
axis2_bool_t arg_return)
1562
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1563
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1565
if(_describeInstancesResponseType->is_valid_return &&
1566
arg_return == _describeInstancesResponseType->property_return)
1569
return AXIS2_SUCCESS;
1572
adb_describeInstancesResponseType_reset_return(_describeInstancesResponseType, env);
1574
_describeInstancesResponseType->property_return = arg_return;
1575
_describeInstancesResponseType->is_valid_return = AXIS2_TRUE;
1577
return AXIS2_SUCCESS;
1583
* resetter for return
1585
axis2_status_t AXIS2_CALL
1586
adb_describeInstancesResponseType_reset_return(
1587
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1588
const axutil_env_t *env)
1592
void *element = NULL;
1594
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1595
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1598
_describeInstancesResponseType->is_valid_return = AXIS2_FALSE;
1599
return AXIS2_SUCCESS;
1603
* Check whether return is nill
1605
axis2_bool_t AXIS2_CALL
1606
adb_describeInstancesResponseType_is_return_nil(
1607
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1608
const axutil_env_t *env)
1610
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1611
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_TRUE);
1613
return !_describeInstancesResponseType->is_valid_return;
1617
* Set return to nill (currently the same as reset)
1619
axis2_status_t AXIS2_CALL
1620
adb_describeInstancesResponseType_set_return_nil(
1621
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1622
const axutil_env_t *env)
1624
return adb_describeInstancesResponseType_reset_return(_describeInstancesResponseType, env);
1630
* getter for instances.
1632
axutil_array_list_t* AXIS2_CALL
1633
adb_describeInstancesResponseType_get_instances(
1634
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1635
const axutil_env_t *env)
1638
AXIS2_ENV_CHECK(env, NULL);
1639
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, NULL);
1642
return _describeInstancesResponseType->property_instances;
1646
* setter for instances
1648
axis2_status_t AXIS2_CALL
1649
adb_describeInstancesResponseType_set_instances(
1650
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1651
const axutil_env_t *env,
1652
axutil_array_list_t* arg_instances)
1657
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1660
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1661
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1663
if(_describeInstancesResponseType->is_valid_instances &&
1664
arg_instances == _describeInstancesResponseType->property_instances)
1667
return AXIS2_SUCCESS;
1671
size = axutil_array_list_size(arg_instances, env);
1675
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instances has less than minOccurs(0)");
1676
return AXIS2_FAILURE;
1678
for(i = 0; i < size; i ++ )
1680
if(NULL != axutil_array_list_get(arg_instances, env, i))
1682
non_nil_exists = AXIS2_TRUE;
1687
adb_describeInstancesResponseType_reset_instances(_describeInstancesResponseType, env);
1690
if(NULL == arg_instances)
1692
/* We are already done */
1693
return AXIS2_SUCCESS;
1695
_describeInstancesResponseType->property_instances = arg_instances;
1698
_describeInstancesResponseType->is_valid_instances = AXIS2_TRUE;
1702
return AXIS2_SUCCESS;
1707
* Get ith element of instances.
1709
adb_ccInstanceType_t* AXIS2_CALL
1710
adb_describeInstancesResponseType_get_instances_at(
1711
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1712
const axutil_env_t *env, int i)
1714
adb_ccInstanceType_t* ret_val;
1717
AXIS2_ENV_CHECK(env, NULL);
1718
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, NULL);
1721
if(_describeInstancesResponseType->property_instances == NULL)
1723
return (adb_ccInstanceType_t*)0;
1725
ret_val = (adb_ccInstanceType_t*)axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i);
1732
* Set the ith element of instances.
1734
axis2_status_t AXIS2_CALL
1735
adb_describeInstancesResponseType_set_instances_at(
1736
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1737
const axutil_env_t *env, int i,
1738
adb_ccInstanceType_t* arg_instances)
1740
void *element = NULL;
1744
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1748
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1749
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1751
if( _describeInstancesResponseType->is_valid_instances &&
1752
_describeInstancesResponseType->property_instances &&
1754
arg_instances == (adb_ccInstanceType_t*)axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i))
1758
return AXIS2_SUCCESS;
1762
if(NULL == arg_instances)
1764
if(_describeInstancesResponseType->property_instances != NULL)
1766
size = axutil_array_list_size(_describeInstancesResponseType->property_instances, env);
1767
for(j = 0, k = 0; j < size; j ++ )
1769
if(i == j) continue;
1770
if(NULL != axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i))
1773
non_nil_exists = AXIS2_TRUE;
1784
non_nil_exists = AXIS2_TRUE;
1789
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of instances is beinng set to be smaller than the specificed number of minOccurs(0)");
1790
return AXIS2_FAILURE;
1793
if(_describeInstancesResponseType->property_instances == NULL)
1795
_describeInstancesResponseType->property_instances = axutil_array_list_create(env, 10);
1798
/* check whether there already exist an element */
1799
element = axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i);
1805
adb_ccInstanceType_free((adb_ccInstanceType_t*)element, env);
1813
_describeInstancesResponseType->is_valid_instances = AXIS2_FALSE;
1814
axutil_array_list_set(_describeInstancesResponseType->property_instances , env, i, NULL);
1816
return AXIS2_SUCCESS;
1819
axutil_array_list_set(_describeInstancesResponseType->property_instances , env, i, arg_instances);
1820
_describeInstancesResponseType->is_valid_instances = AXIS2_TRUE;
1822
return AXIS2_SUCCESS;
1828
axis2_status_t AXIS2_CALL
1829
adb_describeInstancesResponseType_add_instances(
1830
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1831
const axutil_env_t *env,
1832
adb_ccInstanceType_t* arg_instances)
1836
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1837
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1840
if(NULL == arg_instances)
1843
return AXIS2_SUCCESS;
1848
if(_describeInstancesResponseType->property_instances == NULL)
1850
_describeInstancesResponseType->property_instances = axutil_array_list_create(env, 10);
1852
if(_describeInstancesResponseType->property_instances == NULL)
1854
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for instances");
1855
return AXIS2_FAILURE;
1859
axutil_array_list_add(_describeInstancesResponseType->property_instances , env, arg_instances);
1860
_describeInstancesResponseType->is_valid_instances = AXIS2_TRUE;
1861
return AXIS2_SUCCESS;
1865
* Get the size of the instances array.
1868
adb_describeInstancesResponseType_sizeof_instances(
1869
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1870
const axutil_env_t *env)
1872
AXIS2_ENV_CHECK(env, -1);
1873
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, -1);
1874
if(_describeInstancesResponseType->property_instances == NULL)
1878
return axutil_array_list_size(_describeInstancesResponseType->property_instances, env);
1882
* remove the ith element, same as set_nil_at.
1884
axis2_status_t AXIS2_CALL
1885
adb_describeInstancesResponseType_remove_instances_at(
1886
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1887
const axutil_env_t *env, int i)
1889
return adb_describeInstancesResponseType_set_instances_nil_at(_describeInstancesResponseType, env, i);
1895
* resetter for instances
1897
axis2_status_t AXIS2_CALL
1898
adb_describeInstancesResponseType_reset_instances(
1899
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1900
const axutil_env_t *env)
1904
void *element = NULL;
1906
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1907
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1911
if (_describeInstancesResponseType->property_instances != NULL)
1913
count = axutil_array_list_size(_describeInstancesResponseType->property_instances, env);
1914
for(i = 0; i < count; i ++)
1916
element = axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i);
1924
adb_ccInstanceType_free((adb_ccInstanceType_t*)element, env);
1932
axutil_array_list_free(_describeInstancesResponseType->property_instances, env);
1934
_describeInstancesResponseType->is_valid_instances = AXIS2_FALSE;
1935
return AXIS2_SUCCESS;
1939
* Check whether instances is nill
1941
axis2_bool_t AXIS2_CALL
1942
adb_describeInstancesResponseType_is_instances_nil(
1943
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1944
const axutil_env_t *env)
1946
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1947
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_TRUE);
1949
return !_describeInstancesResponseType->is_valid_instances;
1953
* Set instances to nill (currently the same as reset)
1955
axis2_status_t AXIS2_CALL
1956
adb_describeInstancesResponseType_set_instances_nil(
1957
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1958
const axutil_env_t *env)
1960
return adb_describeInstancesResponseType_reset_instances(_describeInstancesResponseType, env);
1965
* Check whether instances is nill at i
1967
axis2_bool_t AXIS2_CALL
1968
adb_describeInstancesResponseType_is_instances_nil_at(
1969
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1970
const axutil_env_t *env, int i)
1972
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1973
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_TRUE);
1975
return (_describeInstancesResponseType->is_valid_instances == AXIS2_FALSE ||
1976
NULL == _describeInstancesResponseType->property_instances ||
1977
NULL == axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i));
1981
* Set instances to nill at i
1983
axis2_status_t AXIS2_CALL
1984
adb_describeInstancesResponseType_set_instances_nil_at(
1985
adb_describeInstancesResponseType_t* _describeInstancesResponseType,
1986
const axutil_env_t *env, int i)
1988
void *element = NULL;
1991
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1995
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1996
AXIS2_PARAM_CHECK(env->error, _describeInstancesResponseType, AXIS2_FAILURE);
1998
if(_describeInstancesResponseType->property_instances == NULL ||
1999
_describeInstancesResponseType->is_valid_instances == AXIS2_FALSE)
2002
non_nil_exists = AXIS2_FALSE;
2006
size = axutil_array_list_size(_describeInstancesResponseType->property_instances, env);
2007
for(j = 0, k = 0; j < size; j ++ )
2009
if(i == j) continue;
2010
if(NULL != axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i))
2013
non_nil_exists = AXIS2_TRUE;
2025
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of instances is beinng set to be smaller than the specificed number of minOccurs(0)");
2026
return AXIS2_FAILURE;
2029
if(_describeInstancesResponseType->property_instances == NULL)
2031
_describeInstancesResponseType->is_valid_instances = AXIS2_FALSE;
2033
return AXIS2_SUCCESS;
2036
/* check whether there already exist an element */
2037
element = axutil_array_list_get(_describeInstancesResponseType->property_instances, env, i);
2043
adb_ccInstanceType_free((adb_ccInstanceType_t*)element, env);
2051
_describeInstancesResponseType->is_valid_instances = AXIS2_FALSE;
2052
axutil_array_list_set(_describeInstancesResponseType->property_instances , env, i, NULL);
2053
return AXIS2_SUCCESS;
2058
axutil_array_list_set(_describeInstancesResponseType->property_instances , env, i, NULL);
2060
return AXIS2_SUCCESS;