4
* adb_getLogsResponseType.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_getLogsResponseType.h"
13
* This type was generated from the piece of schema that had
14
* name = getLogsResponseType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_getLogsResponseType
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
axis2_char_t* property_serviceTag;
50
axis2_bool_t is_valid_serviceTag;
53
axis2_char_t* property_CCLog;
56
axis2_bool_t is_valid_CCLog;
59
axis2_char_t* property_NCLog;
62
axis2_bool_t is_valid_NCLog;
65
axis2_char_t* property_httpdLog;
68
axis2_bool_t is_valid_httpdLog;
71
axis2_char_t* property_axis2Log;
74
axis2_bool_t is_valid_axis2Log;
81
/************************* Private Function prototypes ********************************/
84
axis2_status_t AXIS2_CALL
85
adb_getLogsResponseType_set_correlationId_nil(
86
adb_getLogsResponseType_t* _getLogsResponseType,
87
const axutil_env_t *env);
90
axis2_status_t AXIS2_CALL
91
adb_getLogsResponseType_set_userId_nil(
92
adb_getLogsResponseType_t* _getLogsResponseType,
93
const axutil_env_t *env);
96
axis2_status_t AXIS2_CALL
97
adb_getLogsResponseType_set_return_nil(
98
adb_getLogsResponseType_t* _getLogsResponseType,
99
const axutil_env_t *env);
102
axis2_status_t AXIS2_CALL
103
adb_getLogsResponseType_set_serviceTag_nil(
104
adb_getLogsResponseType_t* _getLogsResponseType,
105
const axutil_env_t *env);
108
axis2_status_t AXIS2_CALL
109
adb_getLogsResponseType_set_CCLog_nil(
110
adb_getLogsResponseType_t* _getLogsResponseType,
111
const axutil_env_t *env);
114
axis2_status_t AXIS2_CALL
115
adb_getLogsResponseType_set_NCLog_nil(
116
adb_getLogsResponseType_t* _getLogsResponseType,
117
const axutil_env_t *env);
120
axis2_status_t AXIS2_CALL
121
adb_getLogsResponseType_set_httpdLog_nil(
122
adb_getLogsResponseType_t* _getLogsResponseType,
123
const axutil_env_t *env);
126
axis2_status_t AXIS2_CALL
127
adb_getLogsResponseType_set_axis2Log_nil(
128
adb_getLogsResponseType_t* _getLogsResponseType,
129
const axutil_env_t *env);
133
/************************* Function Implmentations ********************************/
134
adb_getLogsResponseType_t* AXIS2_CALL
135
adb_getLogsResponseType_create(
136
const axutil_env_t *env)
138
adb_getLogsResponseType_t *_getLogsResponseType = NULL;
140
AXIS2_ENV_CHECK(env, NULL);
142
_getLogsResponseType = (adb_getLogsResponseType_t *) AXIS2_MALLOC(env->
143
allocator, sizeof(adb_getLogsResponseType_t));
145
if(NULL == _getLogsResponseType)
147
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
151
memset(_getLogsResponseType, 0, sizeof(adb_getLogsResponseType_t));
153
_getLogsResponseType->property_correlationId = NULL;
154
_getLogsResponseType->is_valid_correlationId = AXIS2_FALSE;
155
_getLogsResponseType->property_userId = NULL;
156
_getLogsResponseType->is_valid_userId = AXIS2_FALSE;
157
_getLogsResponseType->property_statusMessage = NULL;
158
_getLogsResponseType->is_valid_statusMessage = AXIS2_FALSE;
159
_getLogsResponseType->is_valid_return = AXIS2_FALSE;
160
_getLogsResponseType->property_serviceTag = NULL;
161
_getLogsResponseType->is_valid_serviceTag = AXIS2_FALSE;
162
_getLogsResponseType->property_CCLog = NULL;
163
_getLogsResponseType->is_valid_CCLog = AXIS2_FALSE;
164
_getLogsResponseType->property_NCLog = NULL;
165
_getLogsResponseType->is_valid_NCLog = AXIS2_FALSE;
166
_getLogsResponseType->property_httpdLog = NULL;
167
_getLogsResponseType->is_valid_httpdLog = AXIS2_FALSE;
168
_getLogsResponseType->property_axis2Log = NULL;
169
_getLogsResponseType->is_valid_axis2Log = AXIS2_FALSE;
172
return _getLogsResponseType;
175
axis2_status_t AXIS2_CALL
176
adb_getLogsResponseType_free (
177
adb_getLogsResponseType_t* _getLogsResponseType,
178
const axutil_env_t *env)
182
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
183
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
185
adb_getLogsResponseType_reset_correlationId(_getLogsResponseType, env);
186
adb_getLogsResponseType_reset_userId(_getLogsResponseType, env);
187
adb_getLogsResponseType_reset_statusMessage(_getLogsResponseType, env);
188
adb_getLogsResponseType_reset_return(_getLogsResponseType, env);
189
adb_getLogsResponseType_reset_serviceTag(_getLogsResponseType, env);
190
adb_getLogsResponseType_reset_CCLog(_getLogsResponseType, env);
191
adb_getLogsResponseType_reset_NCLog(_getLogsResponseType, env);
192
adb_getLogsResponseType_reset_httpdLog(_getLogsResponseType, env);
193
adb_getLogsResponseType_reset_axis2Log(_getLogsResponseType, env);
196
if(_getLogsResponseType)
198
AXIS2_FREE(env->allocator, _getLogsResponseType);
199
_getLogsResponseType = NULL;
201
return AXIS2_SUCCESS;
207
axis2_status_t AXIS2_CALL
208
adb_getLogsResponseType_deserialize(
209
adb_getLogsResponseType_t* _getLogsResponseType,
210
const axutil_env_t *env,
211
axiom_node_t **dp_parent,
212
axis2_bool_t *dp_is_early_node_valid,
213
axis2_bool_t dont_care_minoccurs)
215
axiom_node_t *parent = *dp_parent;
217
axis2_status_t status = AXIS2_SUCCESS;
219
axis2_char_t* text_value = NULL;
220
axutil_qname_t *qname = NULL;
222
axutil_qname_t *element_qname = NULL;
224
axiom_node_t *first_node = NULL;
225
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
226
axiom_node_t *current_node = NULL;
227
axiom_element_t *current_element = NULL;
229
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
230
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
234
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
236
parent = axiom_node_get_next_sibling(parent, env);
240
/* This should be checked before everything */
241
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
242
"Failed in building adb object for getLogsResponseType : "
243
"NULL elemenet can not be passed to deserialize");
244
return AXIS2_FAILURE;
248
first_node = axiom_node_get_first_child(parent, env);
254
* building correlationId element
259
current_node = first_node;
260
is_early_node_valid = AXIS2_FALSE;
263
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
265
current_node = axiom_node_get_next_sibling(current_node, env);
267
if(current_node != NULL)
269
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
270
qname = axiom_element_get_qname(current_element, env, current_node);
273
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
277
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
279
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
281
is_early_node_valid = AXIS2_TRUE;
285
text_value = axiom_element_get_text(current_element, env, current_node);
286
if(text_value != NULL)
288
status = adb_getLogsResponseType_set_correlationId(_getLogsResponseType, env,
295
* axis2_qname_t *qname = NULL;
296
* axiom_attribute_t *the_attri = NULL;
298
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
299
* the_attri = axiom_element_get_attribute(current_element, env, qname);
301
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
303
axiom_attribute_t *the_attri = NULL;
304
axis2_char_t *attrib_text = NULL;
305
axutil_hash_t *attribute_hash = NULL;
307
attribute_hash = axiom_element_get_all_attributes(current_element, env);
312
axutil_hash_index_t *hi;
316
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
318
axutil_hash_this(hi, &key, NULL, &val);
320
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
322
the_attri = (axiom_attribute_t*)val;
330
attrib_text = axiom_attribute_get_value(the_attri, env);
334
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
335
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
338
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
340
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
341
status = AXIS2_FAILURE;
345
/* after all, we found this is a empty string */
346
status = adb_getLogsResponseType_set_correlationId(_getLogsResponseType, env,
351
if(AXIS2_FAILURE == status)
353
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
356
axutil_qname_free(element_qname, env);
358
return AXIS2_FAILURE;
364
axutil_qname_free(element_qname, env);
365
element_qname = NULL;
371
* building userId element
377
* because elements are ordered this works fine
381
if(current_node != NULL && is_early_node_valid)
383
current_node = axiom_node_get_next_sibling(current_node, env);
386
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
388
current_node = axiom_node_get_next_sibling(current_node, env);
390
if(current_node != NULL)
392
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
393
qname = axiom_element_get_qname(current_element, env, current_node);
397
is_early_node_valid = AXIS2_FALSE;
399
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
403
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
405
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
407
is_early_node_valid = AXIS2_TRUE;
411
text_value = axiom_element_get_text(current_element, env, current_node);
412
if(text_value != NULL)
414
status = adb_getLogsResponseType_set_userId(_getLogsResponseType, env,
421
* axis2_qname_t *qname = NULL;
422
* axiom_attribute_t *the_attri = NULL;
424
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
425
* the_attri = axiom_element_get_attribute(current_element, env, qname);
427
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
429
axiom_attribute_t *the_attri = NULL;
430
axis2_char_t *attrib_text = NULL;
431
axutil_hash_t *attribute_hash = NULL;
433
attribute_hash = axiom_element_get_all_attributes(current_element, env);
438
axutil_hash_index_t *hi;
442
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
444
axutil_hash_this(hi, &key, NULL, &val);
446
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
448
the_attri = (axiom_attribute_t*)val;
456
attrib_text = axiom_attribute_get_value(the_attri, env);
460
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
461
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
464
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
466
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
467
status = AXIS2_FAILURE;
471
/* after all, we found this is a empty string */
472
status = adb_getLogsResponseType_set_userId(_getLogsResponseType, env,
477
if(AXIS2_FAILURE == status)
479
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
482
axutil_qname_free(element_qname, env);
484
return AXIS2_FAILURE;
490
axutil_qname_free(element_qname, env);
491
element_qname = NULL;
497
* building statusMessage element
503
* because elements are ordered this works fine
507
if(current_node != NULL && is_early_node_valid)
509
current_node = axiom_node_get_next_sibling(current_node, env);
512
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
514
current_node = axiom_node_get_next_sibling(current_node, env);
516
if(current_node != NULL)
518
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
519
qname = axiom_element_get_qname(current_element, env, current_node);
523
is_early_node_valid = AXIS2_FALSE;
525
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
529
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
531
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
533
is_early_node_valid = AXIS2_TRUE;
537
text_value = axiom_element_get_text(current_element, env, current_node);
538
if(text_value != NULL)
540
status = adb_getLogsResponseType_set_statusMessage(_getLogsResponseType, env,
544
if(AXIS2_FAILURE == status)
546
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
549
axutil_qname_free(element_qname, env);
551
return AXIS2_FAILURE;
557
axutil_qname_free(element_qname, env);
558
element_qname = NULL;
564
* building return element
570
* because elements are ordered this works fine
574
if(current_node != NULL && is_early_node_valid)
576
current_node = axiom_node_get_next_sibling(current_node, env);
579
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
581
current_node = axiom_node_get_next_sibling(current_node, env);
583
if(current_node != NULL)
585
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
586
qname = axiom_element_get_qname(current_element, env, current_node);
590
is_early_node_valid = AXIS2_FALSE;
592
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
596
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
598
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
600
is_early_node_valid = AXIS2_TRUE;
604
text_value = axiom_element_get_text(current_element, env, current_node);
605
if(text_value != NULL)
607
if (!axutil_strcasecmp(text_value , "true"))
609
status = adb_getLogsResponseType_set_return(_getLogsResponseType, env,
614
status = adb_getLogsResponseType_set_return(_getLogsResponseType, env,
621
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
622
status = AXIS2_FAILURE;
625
if(AXIS2_FAILURE == status)
627
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
630
axutil_qname_free(element_qname, env);
632
return AXIS2_FAILURE;
638
axutil_qname_free(element_qname, env);
639
element_qname = NULL;
645
* building serviceTag element
651
* because elements are ordered this works fine
655
if(current_node != NULL && is_early_node_valid)
657
current_node = axiom_node_get_next_sibling(current_node, env);
660
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
662
current_node = axiom_node_get_next_sibling(current_node, env);
664
if(current_node != NULL)
666
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
667
qname = axiom_element_get_qname(current_element, env, current_node);
671
is_early_node_valid = AXIS2_FALSE;
673
element_qname = axutil_qname_create(env, "serviceTag", "http://eucalyptus.ucsb.edu/", NULL);
677
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
679
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
681
is_early_node_valid = AXIS2_TRUE;
685
text_value = axiom_element_get_text(current_element, env, current_node);
686
if(text_value != NULL)
688
status = adb_getLogsResponseType_set_serviceTag(_getLogsResponseType, env,
695
* axis2_qname_t *qname = NULL;
696
* axiom_attribute_t *the_attri = NULL;
698
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
699
* the_attri = axiom_element_get_attribute(current_element, env, qname);
701
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
703
axiom_attribute_t *the_attri = NULL;
704
axis2_char_t *attrib_text = NULL;
705
axutil_hash_t *attribute_hash = NULL;
707
attribute_hash = axiom_element_get_all_attributes(current_element, env);
712
axutil_hash_index_t *hi;
716
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
718
axutil_hash_this(hi, &key, NULL, &val);
720
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
722
the_attri = (axiom_attribute_t*)val;
730
attrib_text = axiom_attribute_get_value(the_attri, env);
734
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
735
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
738
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
740
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element serviceTag");
741
status = AXIS2_FAILURE;
745
/* after all, we found this is a empty string */
746
status = adb_getLogsResponseType_set_serviceTag(_getLogsResponseType, env,
751
if(AXIS2_FAILURE == status)
753
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for serviceTag ");
756
axutil_qname_free(element_qname, env);
758
return AXIS2_FAILURE;
764
axutil_qname_free(element_qname, env);
765
element_qname = NULL;
771
* building CCLog element
777
* because elements are ordered this works fine
781
if(current_node != NULL && is_early_node_valid)
783
current_node = axiom_node_get_next_sibling(current_node, env);
786
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
788
current_node = axiom_node_get_next_sibling(current_node, env);
790
if(current_node != NULL)
792
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
793
qname = axiom_element_get_qname(current_element, env, current_node);
797
is_early_node_valid = AXIS2_FALSE;
799
element_qname = axutil_qname_create(env, "CCLog", "http://eucalyptus.ucsb.edu/", NULL);
803
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
805
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
807
is_early_node_valid = AXIS2_TRUE;
811
text_value = axiom_element_get_text(current_element, env, current_node);
812
if(text_value != NULL)
814
status = adb_getLogsResponseType_set_CCLog(_getLogsResponseType, env,
821
* axis2_qname_t *qname = NULL;
822
* axiom_attribute_t *the_attri = NULL;
824
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
825
* the_attri = axiom_element_get_attribute(current_element, env, qname);
827
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
829
axiom_attribute_t *the_attri = NULL;
830
axis2_char_t *attrib_text = NULL;
831
axutil_hash_t *attribute_hash = NULL;
833
attribute_hash = axiom_element_get_all_attributes(current_element, env);
838
axutil_hash_index_t *hi;
842
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
844
axutil_hash_this(hi, &key, NULL, &val);
846
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
848
the_attri = (axiom_attribute_t*)val;
856
attrib_text = axiom_attribute_get_value(the_attri, env);
860
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
861
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
864
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
866
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element CCLog");
867
status = AXIS2_FAILURE;
871
/* after all, we found this is a empty string */
872
status = adb_getLogsResponseType_set_CCLog(_getLogsResponseType, env,
877
if(AXIS2_FAILURE == status)
879
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for CCLog ");
882
axutil_qname_free(element_qname, env);
884
return AXIS2_FAILURE;
890
axutil_qname_free(element_qname, env);
891
element_qname = NULL;
897
* building NCLog element
903
* because elements are ordered this works fine
907
if(current_node != NULL && is_early_node_valid)
909
current_node = axiom_node_get_next_sibling(current_node, env);
912
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
914
current_node = axiom_node_get_next_sibling(current_node, env);
916
if(current_node != NULL)
918
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
919
qname = axiom_element_get_qname(current_element, env, current_node);
923
is_early_node_valid = AXIS2_FALSE;
925
element_qname = axutil_qname_create(env, "NCLog", "http://eucalyptus.ucsb.edu/", NULL);
929
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
931
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
933
is_early_node_valid = AXIS2_TRUE;
937
text_value = axiom_element_get_text(current_element, env, current_node);
938
if(text_value != NULL)
940
status = adb_getLogsResponseType_set_NCLog(_getLogsResponseType, env,
947
* axis2_qname_t *qname = NULL;
948
* axiom_attribute_t *the_attri = NULL;
950
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
951
* the_attri = axiom_element_get_attribute(current_element, env, qname);
953
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
955
axiom_attribute_t *the_attri = NULL;
956
axis2_char_t *attrib_text = NULL;
957
axutil_hash_t *attribute_hash = NULL;
959
attribute_hash = axiom_element_get_all_attributes(current_element, env);
964
axutil_hash_index_t *hi;
968
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
970
axutil_hash_this(hi, &key, NULL, &val);
972
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
974
the_attri = (axiom_attribute_t*)val;
982
attrib_text = axiom_attribute_get_value(the_attri, env);
986
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
987
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
990
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
992
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element NCLog");
993
status = AXIS2_FAILURE;
997
/* after all, we found this is a empty string */
998
status = adb_getLogsResponseType_set_NCLog(_getLogsResponseType, env,
1003
if(AXIS2_FAILURE == status)
1005
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for NCLog ");
1008
axutil_qname_free(element_qname, env);
1010
return AXIS2_FAILURE;
1016
axutil_qname_free(element_qname, env);
1017
element_qname = NULL;
1023
* building httpdLog element
1029
* because elements are ordered this works fine
1033
if(current_node != NULL && is_early_node_valid)
1035
current_node = axiom_node_get_next_sibling(current_node, env);
1038
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1040
current_node = axiom_node_get_next_sibling(current_node, env);
1042
if(current_node != NULL)
1044
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1045
qname = axiom_element_get_qname(current_element, env, current_node);
1049
is_early_node_valid = AXIS2_FALSE;
1051
element_qname = axutil_qname_create(env, "httpdLog", "http://eucalyptus.ucsb.edu/", NULL);
1055
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1057
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1059
is_early_node_valid = AXIS2_TRUE;
1063
text_value = axiom_element_get_text(current_element, env, current_node);
1064
if(text_value != NULL)
1066
status = adb_getLogsResponseType_set_httpdLog(_getLogsResponseType, env,
1073
* axis2_qname_t *qname = NULL;
1074
* axiom_attribute_t *the_attri = NULL;
1076
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1077
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1079
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1081
axiom_attribute_t *the_attri = NULL;
1082
axis2_char_t *attrib_text = NULL;
1083
axutil_hash_t *attribute_hash = NULL;
1085
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1090
axutil_hash_index_t *hi;
1094
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1096
axutil_hash_this(hi, &key, NULL, &val);
1098
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1100
the_attri = (axiom_attribute_t*)val;
1108
attrib_text = axiom_attribute_get_value(the_attri, env);
1112
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1113
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1116
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1118
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element httpdLog");
1119
status = AXIS2_FAILURE;
1123
/* after all, we found this is a empty string */
1124
status = adb_getLogsResponseType_set_httpdLog(_getLogsResponseType, env,
1129
if(AXIS2_FAILURE == status)
1131
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for httpdLog ");
1134
axutil_qname_free(element_qname, env);
1136
return AXIS2_FAILURE;
1142
axutil_qname_free(element_qname, env);
1143
element_qname = NULL;
1149
* building axis2Log element
1155
* because elements are ordered this works fine
1159
if(current_node != NULL && is_early_node_valid)
1161
current_node = axiom_node_get_next_sibling(current_node, env);
1164
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1166
current_node = axiom_node_get_next_sibling(current_node, env);
1168
if(current_node != NULL)
1170
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1171
qname = axiom_element_get_qname(current_element, env, current_node);
1175
is_early_node_valid = AXIS2_FALSE;
1177
element_qname = axutil_qname_create(env, "axis2Log", "http://eucalyptus.ucsb.edu/", NULL);
1181
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
1183
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
1185
is_early_node_valid = AXIS2_TRUE;
1189
text_value = axiom_element_get_text(current_element, env, current_node);
1190
if(text_value != NULL)
1192
status = adb_getLogsResponseType_set_axis2Log(_getLogsResponseType, env,
1199
* axis2_qname_t *qname = NULL;
1200
* axiom_attribute_t *the_attri = NULL;
1202
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1203
* the_attri = axiom_element_get_attribute(current_element, env, qname);
1205
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
1207
axiom_attribute_t *the_attri = NULL;
1208
axis2_char_t *attrib_text = NULL;
1209
axutil_hash_t *attribute_hash = NULL;
1211
attribute_hash = axiom_element_get_all_attributes(current_element, env);
1216
axutil_hash_index_t *hi;
1220
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
1222
axutil_hash_this(hi, &key, NULL, &val);
1224
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1226
the_attri = (axiom_attribute_t*)val;
1234
attrib_text = axiom_attribute_get_value(the_attri, env);
1238
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
1239
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
1242
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
1244
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element axis2Log");
1245
status = AXIS2_FAILURE;
1249
/* after all, we found this is a empty string */
1250
status = adb_getLogsResponseType_set_axis2Log(_getLogsResponseType, env,
1255
if(AXIS2_FAILURE == status)
1257
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for axis2Log ");
1260
axutil_qname_free(element_qname, env);
1262
return AXIS2_FAILURE;
1268
axutil_qname_free(element_qname, env);
1269
element_qname = NULL;
1275
axis2_bool_t AXIS2_CALL
1276
adb_getLogsResponseType_is_particle()
1285
adb_getLogsResponseType_declare_parent_namespaces(
1286
adb_getLogsResponseType_t* _getLogsResponseType,
1287
const axutil_env_t *env, axiom_element_t *parent_element,
1288
axutil_hash_t *namespaces, int *next_ns_index)
1291
/* Here this is an empty function, Nothing to declare */
1297
axiom_node_t* AXIS2_CALL
1298
adb_getLogsResponseType_serialize(
1299
adb_getLogsResponseType_t* _getLogsResponseType,
1300
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)
1304
axis2_char_t *string_to_stream;
1307
axiom_node_t *current_node = NULL;
1312
axiom_namespace_t *ns1 = NULL;
1314
axis2_char_t *qname_uri = NULL;
1315
axis2_char_t *qname_prefix = NULL;
1316
axis2_char_t *p_prefix = NULL;
1317
axis2_bool_t ns_already_defined;
1319
axis2_char_t *text_value_1;
1320
axis2_char_t *text_value_1_temp;
1322
axis2_char_t *text_value_2;
1323
axis2_char_t *text_value_2_temp;
1325
axis2_char_t *text_value_3;
1326
axis2_char_t *text_value_3_temp;
1328
axis2_char_t text_value_4[64];
1330
axis2_char_t *text_value_5;
1331
axis2_char_t *text_value_5_temp;
1333
axis2_char_t *text_value_6;
1334
axis2_char_t *text_value_6_temp;
1336
axis2_char_t *text_value_7;
1337
axis2_char_t *text_value_7_temp;
1339
axis2_char_t *text_value_8;
1340
axis2_char_t *text_value_8_temp;
1342
axis2_char_t *text_value_9;
1343
axis2_char_t *text_value_9_temp;
1345
axis2_char_t *start_input_str = NULL;
1346
axis2_char_t *end_input_str = NULL;
1347
unsigned int start_input_str_len = 0;
1348
unsigned int end_input_str_len = 0;
1351
axiom_data_source_t *data_source = NULL;
1352
axutil_stream_t *stream = NULL;
1356
AXIS2_ENV_CHECK(env, NULL);
1357
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
1360
current_node = parent;
1361
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1364
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1368
if(!parent_tag_closed)
1371
string_to_stream = ">";
1372
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1377
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1379
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1380
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1381
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1383
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1384
"http://eucalyptus.ucsb.edu/",
1389
if (!_getLogsResponseType->is_valid_correlationId)
1392
/* no need to complain for minoccurs=0 element */
1398
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1399
(4 + axutil_strlen(p_prefix) +
1400
axutil_strlen("correlationId")));
1402
/* axutil_strlen("<:>") + 1 = 4 */
1403
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1404
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1405
/* axutil_strlen("</:>") + 1 = 5 */
1413
* parsing correlationId element
1418
sprintf(start_input_str, "<%s%scorrelationId>",
1419
p_prefix?p_prefix:"",
1420
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1422
start_input_str_len = axutil_strlen(start_input_str);
1423
sprintf(end_input_str, "</%s%scorrelationId>",
1424
p_prefix?p_prefix:"",
1425
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1426
end_input_str_len = axutil_strlen(end_input_str);
1428
text_value_1 = _getLogsResponseType->property_correlationId;
1430
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1433
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1434
if (text_value_1_temp)
1436
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1437
AXIS2_FREE(env->allocator, text_value_1_temp);
1441
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1444
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1447
AXIS2_FREE(env->allocator,start_input_str);
1448
AXIS2_FREE(env->allocator,end_input_str);
1452
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1454
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1455
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1456
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1458
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1459
"http://eucalyptus.ucsb.edu/",
1464
if (!_getLogsResponseType->is_valid_userId)
1467
/* no need to complain for minoccurs=0 element */
1473
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1474
(4 + axutil_strlen(p_prefix) +
1475
axutil_strlen("userId")));
1477
/* axutil_strlen("<:>") + 1 = 4 */
1478
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1479
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1480
/* axutil_strlen("</:>") + 1 = 5 */
1488
* parsing userId element
1493
sprintf(start_input_str, "<%s%suserId>",
1494
p_prefix?p_prefix:"",
1495
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1497
start_input_str_len = axutil_strlen(start_input_str);
1498
sprintf(end_input_str, "</%s%suserId>",
1499
p_prefix?p_prefix:"",
1500
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1501
end_input_str_len = axutil_strlen(end_input_str);
1503
text_value_2 = _getLogsResponseType->property_userId;
1505
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1508
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1509
if (text_value_2_temp)
1511
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1512
AXIS2_FREE(env->allocator, text_value_2_temp);
1516
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1519
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1522
AXIS2_FREE(env->allocator,start_input_str);
1523
AXIS2_FREE(env->allocator,end_input_str);
1527
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1529
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1530
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1531
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1533
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1534
"http://eucalyptus.ucsb.edu/",
1539
if (!_getLogsResponseType->is_valid_statusMessage)
1542
/* no need to complain for minoccurs=0 element */
1548
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1549
(4 + axutil_strlen(p_prefix) +
1550
axutil_strlen("statusMessage")));
1552
/* axutil_strlen("<:>") + 1 = 4 */
1553
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1554
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1555
/* axutil_strlen("</:>") + 1 = 5 */
1563
* parsing statusMessage element
1568
sprintf(start_input_str, "<%s%sstatusMessage>",
1569
p_prefix?p_prefix:"",
1570
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1572
start_input_str_len = axutil_strlen(start_input_str);
1573
sprintf(end_input_str, "</%s%sstatusMessage>",
1574
p_prefix?p_prefix:"",
1575
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1576
end_input_str_len = axutil_strlen(end_input_str);
1578
text_value_3 = _getLogsResponseType->property_statusMessage;
1580
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1583
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1584
if (text_value_3_temp)
1586
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1587
AXIS2_FREE(env->allocator, text_value_3_temp);
1591
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1594
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1597
AXIS2_FREE(env->allocator,start_input_str);
1598
AXIS2_FREE(env->allocator,end_input_str);
1602
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1604
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1605
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1606
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1608
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1609
"http://eucalyptus.ucsb.edu/",
1614
if (!_getLogsResponseType->is_valid_return)
1617
/* no need to complain for minoccurs=0 element */
1623
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1624
(4 + axutil_strlen(p_prefix) +
1625
axutil_strlen("return")));
1627
/* axutil_strlen("<:>") + 1 = 4 */
1628
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1629
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1630
/* axutil_strlen("</:>") + 1 = 5 */
1638
* parsing return element
1643
sprintf(start_input_str, "<%s%sreturn>",
1644
p_prefix?p_prefix:"",
1645
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1647
start_input_str_len = axutil_strlen(start_input_str);
1648
sprintf(end_input_str, "</%s%sreturn>",
1649
p_prefix?p_prefix:"",
1650
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1651
end_input_str_len = axutil_strlen(end_input_str);
1653
strcpy(text_value_4, (_getLogsResponseType->property_return)?"true":"false");
1655
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1657
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1659
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1662
AXIS2_FREE(env->allocator,start_input_str);
1663
AXIS2_FREE(env->allocator,end_input_str);
1667
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1669
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1670
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1671
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1673
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1674
"http://eucalyptus.ucsb.edu/",
1679
if (!_getLogsResponseType->is_valid_serviceTag)
1682
/* no need to complain for minoccurs=0 element */
1688
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1689
(4 + axutil_strlen(p_prefix) +
1690
axutil_strlen("serviceTag")));
1692
/* axutil_strlen("<:>") + 1 = 4 */
1693
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1694
(5 + axutil_strlen(p_prefix) + axutil_strlen("serviceTag")));
1695
/* axutil_strlen("</:>") + 1 = 5 */
1703
* parsing serviceTag element
1708
sprintf(start_input_str, "<%s%sserviceTag>",
1709
p_prefix?p_prefix:"",
1710
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1712
start_input_str_len = axutil_strlen(start_input_str);
1713
sprintf(end_input_str, "</%s%sserviceTag>",
1714
p_prefix?p_prefix:"",
1715
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1716
end_input_str_len = axutil_strlen(end_input_str);
1718
text_value_5 = _getLogsResponseType->property_serviceTag;
1720
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1723
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1724
if (text_value_5_temp)
1726
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1727
AXIS2_FREE(env->allocator, text_value_5_temp);
1731
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1734
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1737
AXIS2_FREE(env->allocator,start_input_str);
1738
AXIS2_FREE(env->allocator,end_input_str);
1742
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1744
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1745
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1746
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1748
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1749
"http://eucalyptus.ucsb.edu/",
1754
if (!_getLogsResponseType->is_valid_CCLog)
1757
/* no need to complain for minoccurs=0 element */
1763
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1764
(4 + axutil_strlen(p_prefix) +
1765
axutil_strlen("CCLog")));
1767
/* axutil_strlen("<:>") + 1 = 4 */
1768
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1769
(5 + axutil_strlen(p_prefix) + axutil_strlen("CCLog")));
1770
/* axutil_strlen("</:>") + 1 = 5 */
1778
* parsing CCLog element
1783
sprintf(start_input_str, "<%s%sCCLog>",
1784
p_prefix?p_prefix:"",
1785
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1787
start_input_str_len = axutil_strlen(start_input_str);
1788
sprintf(end_input_str, "</%s%sCCLog>",
1789
p_prefix?p_prefix:"",
1790
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1791
end_input_str_len = axutil_strlen(end_input_str);
1793
text_value_6 = _getLogsResponseType->property_CCLog;
1795
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1798
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1799
if (text_value_6_temp)
1801
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1802
AXIS2_FREE(env->allocator, text_value_6_temp);
1806
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1809
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1812
AXIS2_FREE(env->allocator,start_input_str);
1813
AXIS2_FREE(env->allocator,end_input_str);
1817
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1819
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1820
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1821
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1823
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1824
"http://eucalyptus.ucsb.edu/",
1829
if (!_getLogsResponseType->is_valid_NCLog)
1832
/* no need to complain for minoccurs=0 element */
1838
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1839
(4 + axutil_strlen(p_prefix) +
1840
axutil_strlen("NCLog")));
1842
/* axutil_strlen("<:>") + 1 = 4 */
1843
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1844
(5 + axutil_strlen(p_prefix) + axutil_strlen("NCLog")));
1845
/* axutil_strlen("</:>") + 1 = 5 */
1853
* parsing NCLog element
1858
sprintf(start_input_str, "<%s%sNCLog>",
1859
p_prefix?p_prefix:"",
1860
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1862
start_input_str_len = axutil_strlen(start_input_str);
1863
sprintf(end_input_str, "</%s%sNCLog>",
1864
p_prefix?p_prefix:"",
1865
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1866
end_input_str_len = axutil_strlen(end_input_str);
1868
text_value_7 = _getLogsResponseType->property_NCLog;
1870
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1873
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1874
if (text_value_7_temp)
1876
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
1877
AXIS2_FREE(env->allocator, text_value_7_temp);
1881
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1884
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1887
AXIS2_FREE(env->allocator,start_input_str);
1888
AXIS2_FREE(env->allocator,end_input_str);
1892
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1894
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1895
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1896
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1898
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1899
"http://eucalyptus.ucsb.edu/",
1904
if (!_getLogsResponseType->is_valid_httpdLog)
1907
/* no need to complain for minoccurs=0 element */
1913
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1914
(4 + axutil_strlen(p_prefix) +
1915
axutil_strlen("httpdLog")));
1917
/* axutil_strlen("<:>") + 1 = 4 */
1918
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1919
(5 + axutil_strlen(p_prefix) + axutil_strlen("httpdLog")));
1920
/* axutil_strlen("</:>") + 1 = 5 */
1928
* parsing httpdLog element
1933
sprintf(start_input_str, "<%s%shttpdLog>",
1934
p_prefix?p_prefix:"",
1935
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1937
start_input_str_len = axutil_strlen(start_input_str);
1938
sprintf(end_input_str, "</%s%shttpdLog>",
1939
p_prefix?p_prefix:"",
1940
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1941
end_input_str_len = axutil_strlen(end_input_str);
1943
text_value_8 = _getLogsResponseType->property_httpdLog;
1945
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1948
text_value_8_temp = axutil_xml_quote_string(env, text_value_8, AXIS2_TRUE);
1949
if (text_value_8_temp)
1951
axutil_stream_write(stream, env, text_value_8_temp, axutil_strlen(text_value_8_temp));
1952
AXIS2_FREE(env->allocator, text_value_8_temp);
1956
axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
1959
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1962
AXIS2_FREE(env->allocator,start_input_str);
1963
AXIS2_FREE(env->allocator,end_input_str);
1967
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1969
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1970
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1971
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1973
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1974
"http://eucalyptus.ucsb.edu/",
1979
if (!_getLogsResponseType->is_valid_axis2Log)
1982
/* no need to complain for minoccurs=0 element */
1988
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1989
(4 + axutil_strlen(p_prefix) +
1990
axutil_strlen("axis2Log")));
1992
/* axutil_strlen("<:>") + 1 = 4 */
1993
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1994
(5 + axutil_strlen(p_prefix) + axutil_strlen("axis2Log")));
1995
/* axutil_strlen("</:>") + 1 = 5 */
2003
* parsing axis2Log element
2008
sprintf(start_input_str, "<%s%saxis2Log>",
2009
p_prefix?p_prefix:"",
2010
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2012
start_input_str_len = axutil_strlen(start_input_str);
2013
sprintf(end_input_str, "</%s%saxis2Log>",
2014
p_prefix?p_prefix:"",
2015
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2016
end_input_str_len = axutil_strlen(end_input_str);
2018
text_value_9 = _getLogsResponseType->property_axis2Log;
2020
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2023
text_value_9_temp = axutil_xml_quote_string(env, text_value_9, AXIS2_TRUE);
2024
if (text_value_9_temp)
2026
axutil_stream_write(stream, env, text_value_9_temp, axutil_strlen(text_value_9_temp));
2027
AXIS2_FREE(env->allocator, text_value_9_temp);
2031
axutil_stream_write(stream, env, text_value_9, axutil_strlen(text_value_9));
2034
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2037
AXIS2_FREE(env->allocator,start_input_str);
2038
AXIS2_FREE(env->allocator,end_input_str);
2050
* getter for correlationId.
2052
axis2_char_t* AXIS2_CALL
2053
adb_getLogsResponseType_get_correlationId(
2054
adb_getLogsResponseType_t* _getLogsResponseType,
2055
const axutil_env_t *env)
2058
AXIS2_ENV_CHECK(env, NULL);
2059
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2062
return _getLogsResponseType->property_correlationId;
2066
* setter for correlationId
2068
axis2_status_t AXIS2_CALL
2069
adb_getLogsResponseType_set_correlationId(
2070
adb_getLogsResponseType_t* _getLogsResponseType,
2071
const axutil_env_t *env,
2072
const axis2_char_t* arg_correlationId)
2076
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2077
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2079
if(_getLogsResponseType->is_valid_correlationId &&
2080
arg_correlationId == _getLogsResponseType->property_correlationId)
2083
return AXIS2_SUCCESS;
2086
adb_getLogsResponseType_reset_correlationId(_getLogsResponseType, env);
2089
if(NULL == arg_correlationId)
2091
/* We are already done */
2092
return AXIS2_SUCCESS;
2094
_getLogsResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
2095
if(NULL == _getLogsResponseType->property_correlationId)
2097
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
2098
return AXIS2_FAILURE;
2100
_getLogsResponseType->is_valid_correlationId = AXIS2_TRUE;
2102
return AXIS2_SUCCESS;
2108
* resetter for correlationId
2110
axis2_status_t AXIS2_CALL
2111
adb_getLogsResponseType_reset_correlationId(
2112
adb_getLogsResponseType_t* _getLogsResponseType,
2113
const axutil_env_t *env)
2117
void *element = NULL;
2119
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2120
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2126
if(_getLogsResponseType->property_correlationId != NULL)
2130
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_correlationId);
2131
_getLogsResponseType->property_correlationId = NULL;
2136
_getLogsResponseType->is_valid_correlationId = AXIS2_FALSE;
2137
return AXIS2_SUCCESS;
2141
* Check whether correlationId is nill
2143
axis2_bool_t AXIS2_CALL
2144
adb_getLogsResponseType_is_correlationId_nil(
2145
adb_getLogsResponseType_t* _getLogsResponseType,
2146
const axutil_env_t *env)
2148
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2149
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2151
return !_getLogsResponseType->is_valid_correlationId;
2155
* Set correlationId to nill (currently the same as reset)
2157
axis2_status_t AXIS2_CALL
2158
adb_getLogsResponseType_set_correlationId_nil(
2159
adb_getLogsResponseType_t* _getLogsResponseType,
2160
const axutil_env_t *env)
2162
return adb_getLogsResponseType_reset_correlationId(_getLogsResponseType, env);
2168
* getter for userId.
2170
axis2_char_t* AXIS2_CALL
2171
adb_getLogsResponseType_get_userId(
2172
adb_getLogsResponseType_t* _getLogsResponseType,
2173
const axutil_env_t *env)
2176
AXIS2_ENV_CHECK(env, NULL);
2177
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2180
return _getLogsResponseType->property_userId;
2186
axis2_status_t AXIS2_CALL
2187
adb_getLogsResponseType_set_userId(
2188
adb_getLogsResponseType_t* _getLogsResponseType,
2189
const axutil_env_t *env,
2190
const axis2_char_t* arg_userId)
2194
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2195
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2197
if(_getLogsResponseType->is_valid_userId &&
2198
arg_userId == _getLogsResponseType->property_userId)
2201
return AXIS2_SUCCESS;
2204
adb_getLogsResponseType_reset_userId(_getLogsResponseType, env);
2207
if(NULL == arg_userId)
2209
/* We are already done */
2210
return AXIS2_SUCCESS;
2212
_getLogsResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
2213
if(NULL == _getLogsResponseType->property_userId)
2215
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
2216
return AXIS2_FAILURE;
2218
_getLogsResponseType->is_valid_userId = AXIS2_TRUE;
2220
return AXIS2_SUCCESS;
2226
* resetter for userId
2228
axis2_status_t AXIS2_CALL
2229
adb_getLogsResponseType_reset_userId(
2230
adb_getLogsResponseType_t* _getLogsResponseType,
2231
const axutil_env_t *env)
2235
void *element = NULL;
2237
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2238
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2244
if(_getLogsResponseType->property_userId != NULL)
2248
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_userId);
2249
_getLogsResponseType->property_userId = NULL;
2254
_getLogsResponseType->is_valid_userId = AXIS2_FALSE;
2255
return AXIS2_SUCCESS;
2259
* Check whether userId is nill
2261
axis2_bool_t AXIS2_CALL
2262
adb_getLogsResponseType_is_userId_nil(
2263
adb_getLogsResponseType_t* _getLogsResponseType,
2264
const axutil_env_t *env)
2266
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2267
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2269
return !_getLogsResponseType->is_valid_userId;
2273
* Set userId to nill (currently the same as reset)
2275
axis2_status_t AXIS2_CALL
2276
adb_getLogsResponseType_set_userId_nil(
2277
adb_getLogsResponseType_t* _getLogsResponseType,
2278
const axutil_env_t *env)
2280
return adb_getLogsResponseType_reset_userId(_getLogsResponseType, env);
2286
* getter for statusMessage.
2288
axis2_char_t* AXIS2_CALL
2289
adb_getLogsResponseType_get_statusMessage(
2290
adb_getLogsResponseType_t* _getLogsResponseType,
2291
const axutil_env_t *env)
2294
AXIS2_ENV_CHECK(env, NULL);
2295
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2298
return _getLogsResponseType->property_statusMessage;
2302
* setter for statusMessage
2304
axis2_status_t AXIS2_CALL
2305
adb_getLogsResponseType_set_statusMessage(
2306
adb_getLogsResponseType_t* _getLogsResponseType,
2307
const axutil_env_t *env,
2308
const axis2_char_t* arg_statusMessage)
2312
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2313
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2315
if(_getLogsResponseType->is_valid_statusMessage &&
2316
arg_statusMessage == _getLogsResponseType->property_statusMessage)
2319
return AXIS2_SUCCESS;
2322
adb_getLogsResponseType_reset_statusMessage(_getLogsResponseType, env);
2325
if(NULL == arg_statusMessage)
2327
/* We are already done */
2328
return AXIS2_SUCCESS;
2330
_getLogsResponseType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
2331
if(NULL == _getLogsResponseType->property_statusMessage)
2333
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
2334
return AXIS2_FAILURE;
2336
_getLogsResponseType->is_valid_statusMessage = AXIS2_TRUE;
2338
return AXIS2_SUCCESS;
2344
* resetter for statusMessage
2346
axis2_status_t AXIS2_CALL
2347
adb_getLogsResponseType_reset_statusMessage(
2348
adb_getLogsResponseType_t* _getLogsResponseType,
2349
const axutil_env_t *env)
2353
void *element = NULL;
2355
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2356
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2362
if(_getLogsResponseType->property_statusMessage != NULL)
2366
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_statusMessage);
2367
_getLogsResponseType->property_statusMessage = NULL;
2372
_getLogsResponseType->is_valid_statusMessage = AXIS2_FALSE;
2373
return AXIS2_SUCCESS;
2377
* Check whether statusMessage is nill
2379
axis2_bool_t AXIS2_CALL
2380
adb_getLogsResponseType_is_statusMessage_nil(
2381
adb_getLogsResponseType_t* _getLogsResponseType,
2382
const axutil_env_t *env)
2384
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2385
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2387
return !_getLogsResponseType->is_valid_statusMessage;
2391
* Set statusMessage to nill (currently the same as reset)
2393
axis2_status_t AXIS2_CALL
2394
adb_getLogsResponseType_set_statusMessage_nil(
2395
adb_getLogsResponseType_t* _getLogsResponseType,
2396
const axutil_env_t *env)
2398
return adb_getLogsResponseType_reset_statusMessage(_getLogsResponseType, env);
2404
* getter for return.
2406
axis2_bool_t AXIS2_CALL
2407
adb_getLogsResponseType_get_return(
2408
adb_getLogsResponseType_t* _getLogsResponseType,
2409
const axutil_env_t *env)
2412
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
2413
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, (axis2_bool_t)0);
2416
return _getLogsResponseType->property_return;
2422
axis2_status_t AXIS2_CALL
2423
adb_getLogsResponseType_set_return(
2424
adb_getLogsResponseType_t* _getLogsResponseType,
2425
const axutil_env_t *env,
2426
axis2_bool_t arg_return)
2430
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2431
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2433
if(_getLogsResponseType->is_valid_return &&
2434
arg_return == _getLogsResponseType->property_return)
2437
return AXIS2_SUCCESS;
2440
adb_getLogsResponseType_reset_return(_getLogsResponseType, env);
2442
_getLogsResponseType->property_return = arg_return;
2443
_getLogsResponseType->is_valid_return = AXIS2_TRUE;
2445
return AXIS2_SUCCESS;
2451
* resetter for return
2453
axis2_status_t AXIS2_CALL
2454
adb_getLogsResponseType_reset_return(
2455
adb_getLogsResponseType_t* _getLogsResponseType,
2456
const axutil_env_t *env)
2460
void *element = NULL;
2462
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2463
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2466
_getLogsResponseType->is_valid_return = AXIS2_FALSE;
2467
return AXIS2_SUCCESS;
2471
* Check whether return is nill
2473
axis2_bool_t AXIS2_CALL
2474
adb_getLogsResponseType_is_return_nil(
2475
adb_getLogsResponseType_t* _getLogsResponseType,
2476
const axutil_env_t *env)
2478
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2479
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2481
return !_getLogsResponseType->is_valid_return;
2485
* Set return to nill (currently the same as reset)
2487
axis2_status_t AXIS2_CALL
2488
adb_getLogsResponseType_set_return_nil(
2489
adb_getLogsResponseType_t* _getLogsResponseType,
2490
const axutil_env_t *env)
2492
return adb_getLogsResponseType_reset_return(_getLogsResponseType, env);
2498
* getter for serviceTag.
2500
axis2_char_t* AXIS2_CALL
2501
adb_getLogsResponseType_get_serviceTag(
2502
adb_getLogsResponseType_t* _getLogsResponseType,
2503
const axutil_env_t *env)
2506
AXIS2_ENV_CHECK(env, NULL);
2507
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2510
return _getLogsResponseType->property_serviceTag;
2514
* setter for serviceTag
2516
axis2_status_t AXIS2_CALL
2517
adb_getLogsResponseType_set_serviceTag(
2518
adb_getLogsResponseType_t* _getLogsResponseType,
2519
const axutil_env_t *env,
2520
const axis2_char_t* arg_serviceTag)
2524
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2525
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2527
if(_getLogsResponseType->is_valid_serviceTag &&
2528
arg_serviceTag == _getLogsResponseType->property_serviceTag)
2531
return AXIS2_SUCCESS;
2534
adb_getLogsResponseType_reset_serviceTag(_getLogsResponseType, env);
2537
if(NULL == arg_serviceTag)
2539
/* We are already done */
2540
return AXIS2_SUCCESS;
2542
_getLogsResponseType->property_serviceTag = (axis2_char_t *)axutil_strdup(env, arg_serviceTag);
2543
if(NULL == _getLogsResponseType->property_serviceTag)
2545
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for serviceTag");
2546
return AXIS2_FAILURE;
2548
_getLogsResponseType->is_valid_serviceTag = AXIS2_TRUE;
2550
return AXIS2_SUCCESS;
2556
* resetter for serviceTag
2558
axis2_status_t AXIS2_CALL
2559
adb_getLogsResponseType_reset_serviceTag(
2560
adb_getLogsResponseType_t* _getLogsResponseType,
2561
const axutil_env_t *env)
2565
void *element = NULL;
2567
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2568
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2574
if(_getLogsResponseType->property_serviceTag != NULL)
2578
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_serviceTag);
2579
_getLogsResponseType->property_serviceTag = NULL;
2584
_getLogsResponseType->is_valid_serviceTag = AXIS2_FALSE;
2585
return AXIS2_SUCCESS;
2589
* Check whether serviceTag is nill
2591
axis2_bool_t AXIS2_CALL
2592
adb_getLogsResponseType_is_serviceTag_nil(
2593
adb_getLogsResponseType_t* _getLogsResponseType,
2594
const axutil_env_t *env)
2596
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2597
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2599
return !_getLogsResponseType->is_valid_serviceTag;
2603
* Set serviceTag to nill (currently the same as reset)
2605
axis2_status_t AXIS2_CALL
2606
adb_getLogsResponseType_set_serviceTag_nil(
2607
adb_getLogsResponseType_t* _getLogsResponseType,
2608
const axutil_env_t *env)
2610
return adb_getLogsResponseType_reset_serviceTag(_getLogsResponseType, env);
2618
axis2_char_t* AXIS2_CALL
2619
adb_getLogsResponseType_get_CCLog(
2620
adb_getLogsResponseType_t* _getLogsResponseType,
2621
const axutil_env_t *env)
2624
AXIS2_ENV_CHECK(env, NULL);
2625
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2628
return _getLogsResponseType->property_CCLog;
2634
axis2_status_t AXIS2_CALL
2635
adb_getLogsResponseType_set_CCLog(
2636
adb_getLogsResponseType_t* _getLogsResponseType,
2637
const axutil_env_t *env,
2638
const axis2_char_t* arg_CCLog)
2642
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2643
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2645
if(_getLogsResponseType->is_valid_CCLog &&
2646
arg_CCLog == _getLogsResponseType->property_CCLog)
2649
return AXIS2_SUCCESS;
2652
adb_getLogsResponseType_reset_CCLog(_getLogsResponseType, env);
2655
if(NULL == arg_CCLog)
2657
/* We are already done */
2658
return AXIS2_SUCCESS;
2660
_getLogsResponseType->property_CCLog = (axis2_char_t *)axutil_strdup(env, arg_CCLog);
2661
if(NULL == _getLogsResponseType->property_CCLog)
2663
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for CCLog");
2664
return AXIS2_FAILURE;
2666
_getLogsResponseType->is_valid_CCLog = AXIS2_TRUE;
2668
return AXIS2_SUCCESS;
2674
* resetter for CCLog
2676
axis2_status_t AXIS2_CALL
2677
adb_getLogsResponseType_reset_CCLog(
2678
adb_getLogsResponseType_t* _getLogsResponseType,
2679
const axutil_env_t *env)
2683
void *element = NULL;
2685
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2686
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2692
if(_getLogsResponseType->property_CCLog != NULL)
2696
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_CCLog);
2697
_getLogsResponseType->property_CCLog = NULL;
2702
_getLogsResponseType->is_valid_CCLog = AXIS2_FALSE;
2703
return AXIS2_SUCCESS;
2707
* Check whether CCLog is nill
2709
axis2_bool_t AXIS2_CALL
2710
adb_getLogsResponseType_is_CCLog_nil(
2711
adb_getLogsResponseType_t* _getLogsResponseType,
2712
const axutil_env_t *env)
2714
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2715
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2717
return !_getLogsResponseType->is_valid_CCLog;
2721
* Set CCLog to nill (currently the same as reset)
2723
axis2_status_t AXIS2_CALL
2724
adb_getLogsResponseType_set_CCLog_nil(
2725
adb_getLogsResponseType_t* _getLogsResponseType,
2726
const axutil_env_t *env)
2728
return adb_getLogsResponseType_reset_CCLog(_getLogsResponseType, env);
2736
axis2_char_t* AXIS2_CALL
2737
adb_getLogsResponseType_get_NCLog(
2738
adb_getLogsResponseType_t* _getLogsResponseType,
2739
const axutil_env_t *env)
2742
AXIS2_ENV_CHECK(env, NULL);
2743
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2746
return _getLogsResponseType->property_NCLog;
2752
axis2_status_t AXIS2_CALL
2753
adb_getLogsResponseType_set_NCLog(
2754
adb_getLogsResponseType_t* _getLogsResponseType,
2755
const axutil_env_t *env,
2756
const axis2_char_t* arg_NCLog)
2760
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2761
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2763
if(_getLogsResponseType->is_valid_NCLog &&
2764
arg_NCLog == _getLogsResponseType->property_NCLog)
2767
return AXIS2_SUCCESS;
2770
adb_getLogsResponseType_reset_NCLog(_getLogsResponseType, env);
2773
if(NULL == arg_NCLog)
2775
/* We are already done */
2776
return AXIS2_SUCCESS;
2778
_getLogsResponseType->property_NCLog = (axis2_char_t *)axutil_strdup(env, arg_NCLog);
2779
if(NULL == _getLogsResponseType->property_NCLog)
2781
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for NCLog");
2782
return AXIS2_FAILURE;
2784
_getLogsResponseType->is_valid_NCLog = AXIS2_TRUE;
2786
return AXIS2_SUCCESS;
2792
* resetter for NCLog
2794
axis2_status_t AXIS2_CALL
2795
adb_getLogsResponseType_reset_NCLog(
2796
adb_getLogsResponseType_t* _getLogsResponseType,
2797
const axutil_env_t *env)
2801
void *element = NULL;
2803
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2804
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2810
if(_getLogsResponseType->property_NCLog != NULL)
2814
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_NCLog);
2815
_getLogsResponseType->property_NCLog = NULL;
2820
_getLogsResponseType->is_valid_NCLog = AXIS2_FALSE;
2821
return AXIS2_SUCCESS;
2825
* Check whether NCLog is nill
2827
axis2_bool_t AXIS2_CALL
2828
adb_getLogsResponseType_is_NCLog_nil(
2829
adb_getLogsResponseType_t* _getLogsResponseType,
2830
const axutil_env_t *env)
2832
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2833
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2835
return !_getLogsResponseType->is_valid_NCLog;
2839
* Set NCLog to nill (currently the same as reset)
2841
axis2_status_t AXIS2_CALL
2842
adb_getLogsResponseType_set_NCLog_nil(
2843
adb_getLogsResponseType_t* _getLogsResponseType,
2844
const axutil_env_t *env)
2846
return adb_getLogsResponseType_reset_NCLog(_getLogsResponseType, env);
2852
* getter for httpdLog.
2854
axis2_char_t* AXIS2_CALL
2855
adb_getLogsResponseType_get_httpdLog(
2856
adb_getLogsResponseType_t* _getLogsResponseType,
2857
const axutil_env_t *env)
2860
AXIS2_ENV_CHECK(env, NULL);
2861
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2864
return _getLogsResponseType->property_httpdLog;
2868
* setter for httpdLog
2870
axis2_status_t AXIS2_CALL
2871
adb_getLogsResponseType_set_httpdLog(
2872
adb_getLogsResponseType_t* _getLogsResponseType,
2873
const axutil_env_t *env,
2874
const axis2_char_t* arg_httpdLog)
2878
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2879
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2881
if(_getLogsResponseType->is_valid_httpdLog &&
2882
arg_httpdLog == _getLogsResponseType->property_httpdLog)
2885
return AXIS2_SUCCESS;
2888
adb_getLogsResponseType_reset_httpdLog(_getLogsResponseType, env);
2891
if(NULL == arg_httpdLog)
2893
/* We are already done */
2894
return AXIS2_SUCCESS;
2896
_getLogsResponseType->property_httpdLog = (axis2_char_t *)axutil_strdup(env, arg_httpdLog);
2897
if(NULL == _getLogsResponseType->property_httpdLog)
2899
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for httpdLog");
2900
return AXIS2_FAILURE;
2902
_getLogsResponseType->is_valid_httpdLog = AXIS2_TRUE;
2904
return AXIS2_SUCCESS;
2910
* resetter for httpdLog
2912
axis2_status_t AXIS2_CALL
2913
adb_getLogsResponseType_reset_httpdLog(
2914
adb_getLogsResponseType_t* _getLogsResponseType,
2915
const axutil_env_t *env)
2919
void *element = NULL;
2921
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2922
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2928
if(_getLogsResponseType->property_httpdLog != NULL)
2932
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_httpdLog);
2933
_getLogsResponseType->property_httpdLog = NULL;
2938
_getLogsResponseType->is_valid_httpdLog = AXIS2_FALSE;
2939
return AXIS2_SUCCESS;
2943
* Check whether httpdLog is nill
2945
axis2_bool_t AXIS2_CALL
2946
adb_getLogsResponseType_is_httpdLog_nil(
2947
adb_getLogsResponseType_t* _getLogsResponseType,
2948
const axutil_env_t *env)
2950
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2951
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2953
return !_getLogsResponseType->is_valid_httpdLog;
2957
* Set httpdLog to nill (currently the same as reset)
2959
axis2_status_t AXIS2_CALL
2960
adb_getLogsResponseType_set_httpdLog_nil(
2961
adb_getLogsResponseType_t* _getLogsResponseType,
2962
const axutil_env_t *env)
2964
return adb_getLogsResponseType_reset_httpdLog(_getLogsResponseType, env);
2970
* getter for axis2Log.
2972
axis2_char_t* AXIS2_CALL
2973
adb_getLogsResponseType_get_axis2Log(
2974
adb_getLogsResponseType_t* _getLogsResponseType,
2975
const axutil_env_t *env)
2978
AXIS2_ENV_CHECK(env, NULL);
2979
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2982
return _getLogsResponseType->property_axis2Log;
2986
* setter for axis2Log
2988
axis2_status_t AXIS2_CALL
2989
adb_getLogsResponseType_set_axis2Log(
2990
adb_getLogsResponseType_t* _getLogsResponseType,
2991
const axutil_env_t *env,
2992
const axis2_char_t* arg_axis2Log)
2996
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2997
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2999
if(_getLogsResponseType->is_valid_axis2Log &&
3000
arg_axis2Log == _getLogsResponseType->property_axis2Log)
3003
return AXIS2_SUCCESS;
3006
adb_getLogsResponseType_reset_axis2Log(_getLogsResponseType, env);
3009
if(NULL == arg_axis2Log)
3011
/* We are already done */
3012
return AXIS2_SUCCESS;
3014
_getLogsResponseType->property_axis2Log = (axis2_char_t *)axutil_strdup(env, arg_axis2Log);
3015
if(NULL == _getLogsResponseType->property_axis2Log)
3017
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for axis2Log");
3018
return AXIS2_FAILURE;
3020
_getLogsResponseType->is_valid_axis2Log = AXIS2_TRUE;
3022
return AXIS2_SUCCESS;
3028
* resetter for axis2Log
3030
axis2_status_t AXIS2_CALL
3031
adb_getLogsResponseType_reset_axis2Log(
3032
adb_getLogsResponseType_t* _getLogsResponseType,
3033
const axutil_env_t *env)
3037
void *element = NULL;
3039
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3040
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
3046
if(_getLogsResponseType->property_axis2Log != NULL)
3050
AXIS2_FREE(env-> allocator, _getLogsResponseType->property_axis2Log);
3051
_getLogsResponseType->property_axis2Log = NULL;
3056
_getLogsResponseType->is_valid_axis2Log = AXIS2_FALSE;
3057
return AXIS2_SUCCESS;
3061
* Check whether axis2Log is nill
3063
axis2_bool_t AXIS2_CALL
3064
adb_getLogsResponseType_is_axis2Log_nil(
3065
adb_getLogsResponseType_t* _getLogsResponseType,
3066
const axutil_env_t *env)
3068
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3069
AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
3071
return !_getLogsResponseType->is_valid_axis2Log;
3075
* Set axis2Log to nill (currently the same as reset)
3077
axis2_status_t AXIS2_CALL
3078
adb_getLogsResponseType_set_axis2Log_nil(
3079
adb_getLogsResponseType_t* _getLogsResponseType,
3080
const axutil_env_t *env)
3082
return adb_getLogsResponseType_reset_axis2Log(_getLogsResponseType, env);
added
removed
gatherlog/generated/adb_getLogsResponseType.c
