4
* adb_getKeysResponseType.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_getKeysResponseType.h"
13
* This type was generated from the piece of schema that had
14
* name = getKeysResponseType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_getKeysResponseType
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_CCcert;
56
axis2_bool_t is_valid_CCcert;
59
axis2_char_t* property_NCcert;
62
axis2_bool_t is_valid_NCcert;
69
/************************* Private Function prototypes ********************************/
72
axis2_status_t AXIS2_CALL
73
adb_getKeysResponseType_set_correlationId_nil(
74
adb_getKeysResponseType_t* _getKeysResponseType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_getKeysResponseType_set_userId_nil(
80
adb_getKeysResponseType_t* _getKeysResponseType,
81
const axutil_env_t *env);
84
axis2_status_t AXIS2_CALL
85
adb_getKeysResponseType_set_return_nil(
86
adb_getKeysResponseType_t* _getKeysResponseType,
87
const axutil_env_t *env);
90
axis2_status_t AXIS2_CALL
91
adb_getKeysResponseType_set_serviceTag_nil(
92
adb_getKeysResponseType_t* _getKeysResponseType,
93
const axutil_env_t *env);
96
axis2_status_t AXIS2_CALL
97
adb_getKeysResponseType_set_CCcert_nil(
98
adb_getKeysResponseType_t* _getKeysResponseType,
99
const axutil_env_t *env);
102
axis2_status_t AXIS2_CALL
103
adb_getKeysResponseType_set_NCcert_nil(
104
adb_getKeysResponseType_t* _getKeysResponseType,
105
const axutil_env_t *env);
109
/************************* Function Implmentations ********************************/
110
adb_getKeysResponseType_t* AXIS2_CALL
111
adb_getKeysResponseType_create(
112
const axutil_env_t *env)
114
adb_getKeysResponseType_t *_getKeysResponseType = NULL;
116
AXIS2_ENV_CHECK(env, NULL);
118
_getKeysResponseType = (adb_getKeysResponseType_t *) AXIS2_MALLOC(env->
119
allocator, sizeof(adb_getKeysResponseType_t));
121
if(NULL == _getKeysResponseType)
123
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
127
memset(_getKeysResponseType, 0, sizeof(adb_getKeysResponseType_t));
129
_getKeysResponseType->property_correlationId = NULL;
130
_getKeysResponseType->is_valid_correlationId = AXIS2_FALSE;
131
_getKeysResponseType->property_userId = NULL;
132
_getKeysResponseType->is_valid_userId = AXIS2_FALSE;
133
_getKeysResponseType->property_statusMessage = NULL;
134
_getKeysResponseType->is_valid_statusMessage = AXIS2_FALSE;
135
_getKeysResponseType->is_valid_return = AXIS2_FALSE;
136
_getKeysResponseType->property_serviceTag = NULL;
137
_getKeysResponseType->is_valid_serviceTag = AXIS2_FALSE;
138
_getKeysResponseType->property_CCcert = NULL;
139
_getKeysResponseType->is_valid_CCcert = AXIS2_FALSE;
140
_getKeysResponseType->property_NCcert = NULL;
141
_getKeysResponseType->is_valid_NCcert = AXIS2_FALSE;
144
return _getKeysResponseType;
147
axis2_status_t AXIS2_CALL
148
adb_getKeysResponseType_free (
149
adb_getKeysResponseType_t* _getKeysResponseType,
150
const axutil_env_t *env)
154
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
155
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
157
adb_getKeysResponseType_reset_correlationId(_getKeysResponseType, env);
158
adb_getKeysResponseType_reset_userId(_getKeysResponseType, env);
159
adb_getKeysResponseType_reset_statusMessage(_getKeysResponseType, env);
160
adb_getKeysResponseType_reset_return(_getKeysResponseType, env);
161
adb_getKeysResponseType_reset_serviceTag(_getKeysResponseType, env);
162
adb_getKeysResponseType_reset_CCcert(_getKeysResponseType, env);
163
adb_getKeysResponseType_reset_NCcert(_getKeysResponseType, env);
166
if(_getKeysResponseType)
168
AXIS2_FREE(env->allocator, _getKeysResponseType);
169
_getKeysResponseType = NULL;
171
return AXIS2_SUCCESS;
177
axis2_status_t AXIS2_CALL
178
adb_getKeysResponseType_deserialize(
179
adb_getKeysResponseType_t* _getKeysResponseType,
180
const axutil_env_t *env,
181
axiom_node_t **dp_parent,
182
axis2_bool_t *dp_is_early_node_valid,
183
axis2_bool_t dont_care_minoccurs)
185
axiom_node_t *parent = *dp_parent;
187
axis2_status_t status = AXIS2_SUCCESS;
189
axis2_char_t* text_value = NULL;
190
axutil_qname_t *qname = NULL;
192
axutil_qname_t *element_qname = NULL;
194
axiom_node_t *first_node = NULL;
195
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
196
axiom_node_t *current_node = NULL;
197
axiom_element_t *current_element = NULL;
199
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
200
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
204
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
206
parent = axiom_node_get_next_sibling(parent, env);
210
/* This should be checked before everything */
211
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
212
"Failed in building adb object for getKeysResponseType : "
213
"NULL elemenet can not be passed to deserialize");
214
return AXIS2_FAILURE;
218
first_node = axiom_node_get_first_child(parent, env);
224
* building correlationId element
229
current_node = first_node;
230
is_early_node_valid = AXIS2_FALSE;
233
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
235
current_node = axiom_node_get_next_sibling(current_node, env);
237
if(current_node != NULL)
239
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
240
qname = axiom_element_get_qname(current_element, env, current_node);
243
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
247
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
249
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
251
is_early_node_valid = AXIS2_TRUE;
255
text_value = axiom_element_get_text(current_element, env, current_node);
256
if(text_value != NULL)
258
status = adb_getKeysResponseType_set_correlationId(_getKeysResponseType, env,
265
* axis2_qname_t *qname = NULL;
266
* axiom_attribute_t *the_attri = NULL;
268
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
269
* the_attri = axiom_element_get_attribute(current_element, env, qname);
271
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
273
axiom_attribute_t *the_attri = NULL;
274
axis2_char_t *attrib_text = NULL;
275
axutil_hash_t *attribute_hash = NULL;
277
attribute_hash = axiom_element_get_all_attributes(current_element, env);
282
axutil_hash_index_t *hi;
286
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
288
axutil_hash_this(hi, &key, NULL, &val);
290
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
292
the_attri = (axiom_attribute_t*)val;
300
attrib_text = axiom_attribute_get_value(the_attri, env);
304
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
305
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
308
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
310
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
311
status = AXIS2_FAILURE;
315
/* after all, we found this is a empty string */
316
status = adb_getKeysResponseType_set_correlationId(_getKeysResponseType, env,
321
if(AXIS2_FAILURE == status)
323
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
326
axutil_qname_free(element_qname, env);
328
return AXIS2_FAILURE;
334
axutil_qname_free(element_qname, env);
335
element_qname = NULL;
341
* building userId element
347
* because elements are ordered this works fine
351
if(current_node != NULL && is_early_node_valid)
353
current_node = axiom_node_get_next_sibling(current_node, env);
356
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
358
current_node = axiom_node_get_next_sibling(current_node, env);
360
if(current_node != NULL)
362
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
363
qname = axiom_element_get_qname(current_element, env, current_node);
367
is_early_node_valid = AXIS2_FALSE;
369
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
373
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
375
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
377
is_early_node_valid = AXIS2_TRUE;
381
text_value = axiom_element_get_text(current_element, env, current_node);
382
if(text_value != NULL)
384
status = adb_getKeysResponseType_set_userId(_getKeysResponseType, env,
391
* axis2_qname_t *qname = NULL;
392
* axiom_attribute_t *the_attri = NULL;
394
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
395
* the_attri = axiom_element_get_attribute(current_element, env, qname);
397
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
399
axiom_attribute_t *the_attri = NULL;
400
axis2_char_t *attrib_text = NULL;
401
axutil_hash_t *attribute_hash = NULL;
403
attribute_hash = axiom_element_get_all_attributes(current_element, env);
408
axutil_hash_index_t *hi;
412
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
414
axutil_hash_this(hi, &key, NULL, &val);
416
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
418
the_attri = (axiom_attribute_t*)val;
426
attrib_text = axiom_attribute_get_value(the_attri, env);
430
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
431
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
434
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
436
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
437
status = AXIS2_FAILURE;
441
/* after all, we found this is a empty string */
442
status = adb_getKeysResponseType_set_userId(_getKeysResponseType, env,
447
if(AXIS2_FAILURE == status)
449
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
452
axutil_qname_free(element_qname, env);
454
return AXIS2_FAILURE;
460
axutil_qname_free(element_qname, env);
461
element_qname = NULL;
467
* building statusMessage element
473
* because elements are ordered this works fine
477
if(current_node != NULL && is_early_node_valid)
479
current_node = axiom_node_get_next_sibling(current_node, env);
482
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
484
current_node = axiom_node_get_next_sibling(current_node, env);
486
if(current_node != NULL)
488
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
489
qname = axiom_element_get_qname(current_element, env, current_node);
493
is_early_node_valid = AXIS2_FALSE;
495
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
499
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
501
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
503
is_early_node_valid = AXIS2_TRUE;
507
text_value = axiom_element_get_text(current_element, env, current_node);
508
if(text_value != NULL)
510
status = adb_getKeysResponseType_set_statusMessage(_getKeysResponseType, env,
514
if(AXIS2_FAILURE == status)
516
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
519
axutil_qname_free(element_qname, env);
521
return AXIS2_FAILURE;
527
axutil_qname_free(element_qname, env);
528
element_qname = NULL;
534
* building return element
540
* because elements are ordered this works fine
544
if(current_node != NULL && is_early_node_valid)
546
current_node = axiom_node_get_next_sibling(current_node, env);
549
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
551
current_node = axiom_node_get_next_sibling(current_node, env);
553
if(current_node != NULL)
555
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
556
qname = axiom_element_get_qname(current_element, env, current_node);
560
is_early_node_valid = AXIS2_FALSE;
562
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
566
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
568
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
570
is_early_node_valid = AXIS2_TRUE;
574
text_value = axiom_element_get_text(current_element, env, current_node);
575
if(text_value != NULL)
577
if (!axutil_strcasecmp(text_value , "true"))
579
status = adb_getKeysResponseType_set_return(_getKeysResponseType, env,
584
status = adb_getKeysResponseType_set_return(_getKeysResponseType, env,
591
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
592
status = AXIS2_FAILURE;
595
if(AXIS2_FAILURE == status)
597
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
600
axutil_qname_free(element_qname, env);
602
return AXIS2_FAILURE;
608
axutil_qname_free(element_qname, env);
609
element_qname = NULL;
615
* building serviceTag element
621
* because elements are ordered this works fine
625
if(current_node != NULL && is_early_node_valid)
627
current_node = axiom_node_get_next_sibling(current_node, env);
630
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
632
current_node = axiom_node_get_next_sibling(current_node, env);
634
if(current_node != NULL)
636
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
637
qname = axiom_element_get_qname(current_element, env, current_node);
641
is_early_node_valid = AXIS2_FALSE;
643
element_qname = axutil_qname_create(env, "serviceTag", "http://eucalyptus.ucsb.edu/", NULL);
647
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
649
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
651
is_early_node_valid = AXIS2_TRUE;
655
text_value = axiom_element_get_text(current_element, env, current_node);
656
if(text_value != NULL)
658
status = adb_getKeysResponseType_set_serviceTag(_getKeysResponseType, env,
665
* axis2_qname_t *qname = NULL;
666
* axiom_attribute_t *the_attri = NULL;
668
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
669
* the_attri = axiom_element_get_attribute(current_element, env, qname);
671
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
673
axiom_attribute_t *the_attri = NULL;
674
axis2_char_t *attrib_text = NULL;
675
axutil_hash_t *attribute_hash = NULL;
677
attribute_hash = axiom_element_get_all_attributes(current_element, env);
682
axutil_hash_index_t *hi;
686
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
688
axutil_hash_this(hi, &key, NULL, &val);
690
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
692
the_attri = (axiom_attribute_t*)val;
700
attrib_text = axiom_attribute_get_value(the_attri, env);
704
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
705
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
708
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
710
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element serviceTag");
711
status = AXIS2_FAILURE;
715
/* after all, we found this is a empty string */
716
status = adb_getKeysResponseType_set_serviceTag(_getKeysResponseType, env,
721
if(AXIS2_FAILURE == status)
723
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for serviceTag ");
726
axutil_qname_free(element_qname, env);
728
return AXIS2_FAILURE;
734
axutil_qname_free(element_qname, env);
735
element_qname = NULL;
741
* building CCcert element
747
* because elements are ordered this works fine
751
if(current_node != NULL && is_early_node_valid)
753
current_node = axiom_node_get_next_sibling(current_node, env);
756
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
758
current_node = axiom_node_get_next_sibling(current_node, env);
760
if(current_node != NULL)
762
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
763
qname = axiom_element_get_qname(current_element, env, current_node);
767
is_early_node_valid = AXIS2_FALSE;
769
element_qname = axutil_qname_create(env, "CCcert", "http://eucalyptus.ucsb.edu/", NULL);
773
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
775
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
777
is_early_node_valid = AXIS2_TRUE;
781
text_value = axiom_element_get_text(current_element, env, current_node);
782
if(text_value != NULL)
784
status = adb_getKeysResponseType_set_CCcert(_getKeysResponseType, env,
791
* axis2_qname_t *qname = NULL;
792
* axiom_attribute_t *the_attri = NULL;
794
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
795
* the_attri = axiom_element_get_attribute(current_element, env, qname);
797
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
799
axiom_attribute_t *the_attri = NULL;
800
axis2_char_t *attrib_text = NULL;
801
axutil_hash_t *attribute_hash = NULL;
803
attribute_hash = axiom_element_get_all_attributes(current_element, env);
808
axutil_hash_index_t *hi;
812
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
814
axutil_hash_this(hi, &key, NULL, &val);
816
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
818
the_attri = (axiom_attribute_t*)val;
826
attrib_text = axiom_attribute_get_value(the_attri, env);
830
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
831
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
834
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
836
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element CCcert");
837
status = AXIS2_FAILURE;
841
/* after all, we found this is a empty string */
842
status = adb_getKeysResponseType_set_CCcert(_getKeysResponseType, env,
847
if(AXIS2_FAILURE == status)
849
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for CCcert ");
852
axutil_qname_free(element_qname, env);
854
return AXIS2_FAILURE;
860
axutil_qname_free(element_qname, env);
861
element_qname = NULL;
867
* building NCcert element
873
* because elements are ordered this works fine
877
if(current_node != NULL && is_early_node_valid)
879
current_node = axiom_node_get_next_sibling(current_node, env);
882
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
884
current_node = axiom_node_get_next_sibling(current_node, env);
886
if(current_node != NULL)
888
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
889
qname = axiom_element_get_qname(current_element, env, current_node);
893
is_early_node_valid = AXIS2_FALSE;
895
element_qname = axutil_qname_create(env, "NCcert", "http://eucalyptus.ucsb.edu/", NULL);
899
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
901
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
903
is_early_node_valid = AXIS2_TRUE;
907
text_value = axiom_element_get_text(current_element, env, current_node);
908
if(text_value != NULL)
910
status = adb_getKeysResponseType_set_NCcert(_getKeysResponseType, env,
917
* axis2_qname_t *qname = NULL;
918
* axiom_attribute_t *the_attri = NULL;
920
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
921
* the_attri = axiom_element_get_attribute(current_element, env, qname);
923
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
925
axiom_attribute_t *the_attri = NULL;
926
axis2_char_t *attrib_text = NULL;
927
axutil_hash_t *attribute_hash = NULL;
929
attribute_hash = axiom_element_get_all_attributes(current_element, env);
934
axutil_hash_index_t *hi;
938
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
940
axutil_hash_this(hi, &key, NULL, &val);
942
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
944
the_attri = (axiom_attribute_t*)val;
952
attrib_text = axiom_attribute_get_value(the_attri, env);
956
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
957
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
960
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
962
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element NCcert");
963
status = AXIS2_FAILURE;
967
/* after all, we found this is a empty string */
968
status = adb_getKeysResponseType_set_NCcert(_getKeysResponseType, env,
973
if(AXIS2_FAILURE == status)
975
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for NCcert ");
978
axutil_qname_free(element_qname, env);
980
return AXIS2_FAILURE;
986
axutil_qname_free(element_qname, env);
987
element_qname = NULL;
993
axis2_bool_t AXIS2_CALL
994
adb_getKeysResponseType_is_particle()
1003
adb_getKeysResponseType_declare_parent_namespaces(
1004
adb_getKeysResponseType_t* _getKeysResponseType,
1005
const axutil_env_t *env, axiom_element_t *parent_element,
1006
axutil_hash_t *namespaces, int *next_ns_index)
1009
/* Here this is an empty function, Nothing to declare */
1015
axiom_node_t* AXIS2_CALL
1016
adb_getKeysResponseType_serialize(
1017
adb_getKeysResponseType_t* _getKeysResponseType,
1018
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)
1022
axis2_char_t *string_to_stream;
1025
axiom_node_t *current_node = NULL;
1030
axiom_namespace_t *ns1 = NULL;
1032
axis2_char_t *qname_uri = NULL;
1033
axis2_char_t *qname_prefix = NULL;
1034
axis2_char_t *p_prefix = NULL;
1035
axis2_bool_t ns_already_defined;
1037
axis2_char_t *text_value_1;
1038
axis2_char_t *text_value_1_temp;
1040
axis2_char_t *text_value_2;
1041
axis2_char_t *text_value_2_temp;
1043
axis2_char_t *text_value_3;
1044
axis2_char_t *text_value_3_temp;
1046
axis2_char_t text_value_4[64];
1048
axis2_char_t *text_value_5;
1049
axis2_char_t *text_value_5_temp;
1051
axis2_char_t *text_value_6;
1052
axis2_char_t *text_value_6_temp;
1054
axis2_char_t *text_value_7;
1055
axis2_char_t *text_value_7_temp;
1057
axis2_char_t *start_input_str = NULL;
1058
axis2_char_t *end_input_str = NULL;
1059
unsigned int start_input_str_len = 0;
1060
unsigned int end_input_str_len = 0;
1063
axiom_data_source_t *data_source = NULL;
1064
axutil_stream_t *stream = NULL;
1068
AXIS2_ENV_CHECK(env, NULL);
1069
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, NULL);
1072
current_node = parent;
1073
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1076
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1080
if(!parent_tag_closed)
1083
string_to_stream = ">";
1084
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1089
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1091
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1092
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1093
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1095
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1096
"http://eucalyptus.ucsb.edu/",
1101
if (!_getKeysResponseType->is_valid_correlationId)
1104
/* no need to complain for minoccurs=0 element */
1110
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1111
(4 + axutil_strlen(p_prefix) +
1112
axutil_strlen("correlationId")));
1114
/* axutil_strlen("<:>") + 1 = 4 */
1115
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1116
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1117
/* axutil_strlen("</:>") + 1 = 5 */
1125
* parsing correlationId element
1130
sprintf(start_input_str, "<%s%scorrelationId>",
1131
p_prefix?p_prefix:"",
1132
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1134
start_input_str_len = axutil_strlen(start_input_str);
1135
sprintf(end_input_str, "</%s%scorrelationId>",
1136
p_prefix?p_prefix:"",
1137
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1138
end_input_str_len = axutil_strlen(end_input_str);
1140
text_value_1 = _getKeysResponseType->property_correlationId;
1142
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1145
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1146
if (text_value_1_temp)
1148
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1149
AXIS2_FREE(env->allocator, text_value_1_temp);
1153
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1156
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1159
AXIS2_FREE(env->allocator,start_input_str);
1160
AXIS2_FREE(env->allocator,end_input_str);
1164
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1166
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1167
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1168
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1170
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1171
"http://eucalyptus.ucsb.edu/",
1176
if (!_getKeysResponseType->is_valid_userId)
1179
/* no need to complain for minoccurs=0 element */
1185
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1186
(4 + axutil_strlen(p_prefix) +
1187
axutil_strlen("userId")));
1189
/* axutil_strlen("<:>") + 1 = 4 */
1190
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1191
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1192
/* axutil_strlen("</:>") + 1 = 5 */
1200
* parsing userId element
1205
sprintf(start_input_str, "<%s%suserId>",
1206
p_prefix?p_prefix:"",
1207
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1209
start_input_str_len = axutil_strlen(start_input_str);
1210
sprintf(end_input_str, "</%s%suserId>",
1211
p_prefix?p_prefix:"",
1212
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1213
end_input_str_len = axutil_strlen(end_input_str);
1215
text_value_2 = _getKeysResponseType->property_userId;
1217
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1220
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1221
if (text_value_2_temp)
1223
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1224
AXIS2_FREE(env->allocator, text_value_2_temp);
1228
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1231
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1234
AXIS2_FREE(env->allocator,start_input_str);
1235
AXIS2_FREE(env->allocator,end_input_str);
1239
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1241
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1242
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1243
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1245
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1246
"http://eucalyptus.ucsb.edu/",
1251
if (!_getKeysResponseType->is_valid_statusMessage)
1254
/* no need to complain for minoccurs=0 element */
1260
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1261
(4 + axutil_strlen(p_prefix) +
1262
axutil_strlen("statusMessage")));
1264
/* axutil_strlen("<:>") + 1 = 4 */
1265
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1266
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1267
/* axutil_strlen("</:>") + 1 = 5 */
1275
* parsing statusMessage element
1280
sprintf(start_input_str, "<%s%sstatusMessage>",
1281
p_prefix?p_prefix:"",
1282
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1284
start_input_str_len = axutil_strlen(start_input_str);
1285
sprintf(end_input_str, "</%s%sstatusMessage>",
1286
p_prefix?p_prefix:"",
1287
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1288
end_input_str_len = axutil_strlen(end_input_str);
1290
text_value_3 = _getKeysResponseType->property_statusMessage;
1292
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1295
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1296
if (text_value_3_temp)
1298
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1299
AXIS2_FREE(env->allocator, text_value_3_temp);
1303
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1306
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1309
AXIS2_FREE(env->allocator,start_input_str);
1310
AXIS2_FREE(env->allocator,end_input_str);
1314
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1316
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1317
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1318
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1320
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1321
"http://eucalyptus.ucsb.edu/",
1326
if (!_getKeysResponseType->is_valid_return)
1329
/* no need to complain for minoccurs=0 element */
1335
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1336
(4 + axutil_strlen(p_prefix) +
1337
axutil_strlen("return")));
1339
/* axutil_strlen("<:>") + 1 = 4 */
1340
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1341
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1342
/* axutil_strlen("</:>") + 1 = 5 */
1350
* parsing return element
1355
sprintf(start_input_str, "<%s%sreturn>",
1356
p_prefix?p_prefix:"",
1357
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1359
start_input_str_len = axutil_strlen(start_input_str);
1360
sprintf(end_input_str, "</%s%sreturn>",
1361
p_prefix?p_prefix:"",
1362
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1363
end_input_str_len = axutil_strlen(end_input_str);
1365
strcpy(text_value_4, (_getKeysResponseType->property_return)?"true":"false");
1367
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1369
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1371
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1374
AXIS2_FREE(env->allocator,start_input_str);
1375
AXIS2_FREE(env->allocator,end_input_str);
1379
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1381
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1382
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1383
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1385
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1386
"http://eucalyptus.ucsb.edu/",
1391
if (!_getKeysResponseType->is_valid_serviceTag)
1394
/* no need to complain for minoccurs=0 element */
1400
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1401
(4 + axutil_strlen(p_prefix) +
1402
axutil_strlen("serviceTag")));
1404
/* axutil_strlen("<:>") + 1 = 4 */
1405
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1406
(5 + axutil_strlen(p_prefix) + axutil_strlen("serviceTag")));
1407
/* axutil_strlen("</:>") + 1 = 5 */
1415
* parsing serviceTag element
1420
sprintf(start_input_str, "<%s%sserviceTag>",
1421
p_prefix?p_prefix:"",
1422
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1424
start_input_str_len = axutil_strlen(start_input_str);
1425
sprintf(end_input_str, "</%s%sserviceTag>",
1426
p_prefix?p_prefix:"",
1427
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1428
end_input_str_len = axutil_strlen(end_input_str);
1430
text_value_5 = _getKeysResponseType->property_serviceTag;
1432
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1435
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1436
if (text_value_5_temp)
1438
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1439
AXIS2_FREE(env->allocator, text_value_5_temp);
1443
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1446
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1449
AXIS2_FREE(env->allocator,start_input_str);
1450
AXIS2_FREE(env->allocator,end_input_str);
1454
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1456
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1457
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1458
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1460
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1461
"http://eucalyptus.ucsb.edu/",
1466
if (!_getKeysResponseType->is_valid_CCcert)
1469
/* no need to complain for minoccurs=0 element */
1475
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1476
(4 + axutil_strlen(p_prefix) +
1477
axutil_strlen("CCcert")));
1479
/* axutil_strlen("<:>") + 1 = 4 */
1480
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1481
(5 + axutil_strlen(p_prefix) + axutil_strlen("CCcert")));
1482
/* axutil_strlen("</:>") + 1 = 5 */
1490
* parsing CCcert element
1495
sprintf(start_input_str, "<%s%sCCcert>",
1496
p_prefix?p_prefix:"",
1497
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1499
start_input_str_len = axutil_strlen(start_input_str);
1500
sprintf(end_input_str, "</%s%sCCcert>",
1501
p_prefix?p_prefix:"",
1502
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1503
end_input_str_len = axutil_strlen(end_input_str);
1505
text_value_6 = _getKeysResponseType->property_CCcert;
1507
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1510
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1511
if (text_value_6_temp)
1513
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1514
AXIS2_FREE(env->allocator, text_value_6_temp);
1518
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1521
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1524
AXIS2_FREE(env->allocator,start_input_str);
1525
AXIS2_FREE(env->allocator,end_input_str);
1529
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1531
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1532
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1533
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1535
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1536
"http://eucalyptus.ucsb.edu/",
1541
if (!_getKeysResponseType->is_valid_NCcert)
1544
/* no need to complain for minoccurs=0 element */
1550
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1551
(4 + axutil_strlen(p_prefix) +
1552
axutil_strlen("NCcert")));
1554
/* axutil_strlen("<:>") + 1 = 4 */
1555
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1556
(5 + axutil_strlen(p_prefix) + axutil_strlen("NCcert")));
1557
/* axutil_strlen("</:>") + 1 = 5 */
1565
* parsing NCcert element
1570
sprintf(start_input_str, "<%s%sNCcert>",
1571
p_prefix?p_prefix:"",
1572
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1574
start_input_str_len = axutil_strlen(start_input_str);
1575
sprintf(end_input_str, "</%s%sNCcert>",
1576
p_prefix?p_prefix:"",
1577
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1578
end_input_str_len = axutil_strlen(end_input_str);
1580
text_value_7 = _getKeysResponseType->property_NCcert;
1582
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1585
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1586
if (text_value_7_temp)
1588
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
1589
AXIS2_FREE(env->allocator, text_value_7_temp);
1593
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1596
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1599
AXIS2_FREE(env->allocator,start_input_str);
1600
AXIS2_FREE(env->allocator,end_input_str);
1612
* getter for correlationId.
1614
axis2_char_t* AXIS2_CALL
1615
adb_getKeysResponseType_get_correlationId(
1616
adb_getKeysResponseType_t* _getKeysResponseType,
1617
const axutil_env_t *env)
1620
AXIS2_ENV_CHECK(env, NULL);
1621
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, NULL);
1624
return _getKeysResponseType->property_correlationId;
1628
* setter for correlationId
1630
axis2_status_t AXIS2_CALL
1631
adb_getKeysResponseType_set_correlationId(
1632
adb_getKeysResponseType_t* _getKeysResponseType,
1633
const axutil_env_t *env,
1634
const axis2_char_t* arg_correlationId)
1638
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1639
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
1641
if(_getKeysResponseType->is_valid_correlationId &&
1642
arg_correlationId == _getKeysResponseType->property_correlationId)
1645
return AXIS2_SUCCESS;
1648
adb_getKeysResponseType_reset_correlationId(_getKeysResponseType, env);
1651
if(NULL == arg_correlationId)
1653
/* We are already done */
1654
return AXIS2_SUCCESS;
1656
_getKeysResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1657
if(NULL == _getKeysResponseType->property_correlationId)
1659
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1660
return AXIS2_FAILURE;
1662
_getKeysResponseType->is_valid_correlationId = AXIS2_TRUE;
1664
return AXIS2_SUCCESS;
1670
* resetter for correlationId
1672
axis2_status_t AXIS2_CALL
1673
adb_getKeysResponseType_reset_correlationId(
1674
adb_getKeysResponseType_t* _getKeysResponseType,
1675
const axutil_env_t *env)
1679
void *element = NULL;
1681
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1682
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
1688
if(_getKeysResponseType->property_correlationId != NULL)
1692
AXIS2_FREE(env-> allocator, _getKeysResponseType->property_correlationId);
1693
_getKeysResponseType->property_correlationId = NULL;
1698
_getKeysResponseType->is_valid_correlationId = AXIS2_FALSE;
1699
return AXIS2_SUCCESS;
1703
* Check whether correlationId is nill
1705
axis2_bool_t AXIS2_CALL
1706
adb_getKeysResponseType_is_correlationId_nil(
1707
adb_getKeysResponseType_t* _getKeysResponseType,
1708
const axutil_env_t *env)
1710
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1711
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_TRUE);
1713
return !_getKeysResponseType->is_valid_correlationId;
1717
* Set correlationId to nill (currently the same as reset)
1719
axis2_status_t AXIS2_CALL
1720
adb_getKeysResponseType_set_correlationId_nil(
1721
adb_getKeysResponseType_t* _getKeysResponseType,
1722
const axutil_env_t *env)
1724
return adb_getKeysResponseType_reset_correlationId(_getKeysResponseType, env);
1730
* getter for userId.
1732
axis2_char_t* AXIS2_CALL
1733
adb_getKeysResponseType_get_userId(
1734
adb_getKeysResponseType_t* _getKeysResponseType,
1735
const axutil_env_t *env)
1738
AXIS2_ENV_CHECK(env, NULL);
1739
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, NULL);
1742
return _getKeysResponseType->property_userId;
1748
axis2_status_t AXIS2_CALL
1749
adb_getKeysResponseType_set_userId(
1750
adb_getKeysResponseType_t* _getKeysResponseType,
1751
const axutil_env_t *env,
1752
const axis2_char_t* arg_userId)
1756
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1757
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
1759
if(_getKeysResponseType->is_valid_userId &&
1760
arg_userId == _getKeysResponseType->property_userId)
1763
return AXIS2_SUCCESS;
1766
adb_getKeysResponseType_reset_userId(_getKeysResponseType, env);
1769
if(NULL == arg_userId)
1771
/* We are already done */
1772
return AXIS2_SUCCESS;
1774
_getKeysResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1775
if(NULL == _getKeysResponseType->property_userId)
1777
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1778
return AXIS2_FAILURE;
1780
_getKeysResponseType->is_valid_userId = AXIS2_TRUE;
1782
return AXIS2_SUCCESS;
1788
* resetter for userId
1790
axis2_status_t AXIS2_CALL
1791
adb_getKeysResponseType_reset_userId(
1792
adb_getKeysResponseType_t* _getKeysResponseType,
1793
const axutil_env_t *env)
1797
void *element = NULL;
1799
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1800
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
1806
if(_getKeysResponseType->property_userId != NULL)
1810
AXIS2_FREE(env-> allocator, _getKeysResponseType->property_userId);
1811
_getKeysResponseType->property_userId = NULL;
1816
_getKeysResponseType->is_valid_userId = AXIS2_FALSE;
1817
return AXIS2_SUCCESS;
1821
* Check whether userId is nill
1823
axis2_bool_t AXIS2_CALL
1824
adb_getKeysResponseType_is_userId_nil(
1825
adb_getKeysResponseType_t* _getKeysResponseType,
1826
const axutil_env_t *env)
1828
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1829
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_TRUE);
1831
return !_getKeysResponseType->is_valid_userId;
1835
* Set userId to nill (currently the same as reset)
1837
axis2_status_t AXIS2_CALL
1838
adb_getKeysResponseType_set_userId_nil(
1839
adb_getKeysResponseType_t* _getKeysResponseType,
1840
const axutil_env_t *env)
1842
return adb_getKeysResponseType_reset_userId(_getKeysResponseType, env);
1848
* getter for statusMessage.
1850
axis2_char_t* AXIS2_CALL
1851
adb_getKeysResponseType_get_statusMessage(
1852
adb_getKeysResponseType_t* _getKeysResponseType,
1853
const axutil_env_t *env)
1856
AXIS2_ENV_CHECK(env, NULL);
1857
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, NULL);
1860
return _getKeysResponseType->property_statusMessage;
1864
* setter for statusMessage
1866
axis2_status_t AXIS2_CALL
1867
adb_getKeysResponseType_set_statusMessage(
1868
adb_getKeysResponseType_t* _getKeysResponseType,
1869
const axutil_env_t *env,
1870
const axis2_char_t* arg_statusMessage)
1874
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1875
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
1877
if(_getKeysResponseType->is_valid_statusMessage &&
1878
arg_statusMessage == _getKeysResponseType->property_statusMessage)
1881
return AXIS2_SUCCESS;
1884
adb_getKeysResponseType_reset_statusMessage(_getKeysResponseType, env);
1887
if(NULL == arg_statusMessage)
1889
/* We are already done */
1890
return AXIS2_SUCCESS;
1892
_getKeysResponseType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1893
if(NULL == _getKeysResponseType->property_statusMessage)
1895
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1896
return AXIS2_FAILURE;
1898
_getKeysResponseType->is_valid_statusMessage = AXIS2_TRUE;
1900
return AXIS2_SUCCESS;
1906
* resetter for statusMessage
1908
axis2_status_t AXIS2_CALL
1909
adb_getKeysResponseType_reset_statusMessage(
1910
adb_getKeysResponseType_t* _getKeysResponseType,
1911
const axutil_env_t *env)
1915
void *element = NULL;
1917
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1918
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
1924
if(_getKeysResponseType->property_statusMessage != NULL)
1928
AXIS2_FREE(env-> allocator, _getKeysResponseType->property_statusMessage);
1929
_getKeysResponseType->property_statusMessage = NULL;
1934
_getKeysResponseType->is_valid_statusMessage = AXIS2_FALSE;
1935
return AXIS2_SUCCESS;
1939
* Check whether statusMessage is nill
1941
axis2_bool_t AXIS2_CALL
1942
adb_getKeysResponseType_is_statusMessage_nil(
1943
adb_getKeysResponseType_t* _getKeysResponseType,
1944
const axutil_env_t *env)
1946
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1947
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_TRUE);
1949
return !_getKeysResponseType->is_valid_statusMessage;
1953
* Set statusMessage to nill (currently the same as reset)
1955
axis2_status_t AXIS2_CALL
1956
adb_getKeysResponseType_set_statusMessage_nil(
1957
adb_getKeysResponseType_t* _getKeysResponseType,
1958
const axutil_env_t *env)
1960
return adb_getKeysResponseType_reset_statusMessage(_getKeysResponseType, env);
1966
* getter for return.
1968
axis2_bool_t AXIS2_CALL
1969
adb_getKeysResponseType_get_return(
1970
adb_getKeysResponseType_t* _getKeysResponseType,
1971
const axutil_env_t *env)
1974
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1975
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, (axis2_bool_t)0);
1978
return _getKeysResponseType->property_return;
1984
axis2_status_t AXIS2_CALL
1985
adb_getKeysResponseType_set_return(
1986
adb_getKeysResponseType_t* _getKeysResponseType,
1987
const axutil_env_t *env,
1988
axis2_bool_t arg_return)
1992
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1993
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
1995
if(_getKeysResponseType->is_valid_return &&
1996
arg_return == _getKeysResponseType->property_return)
1999
return AXIS2_SUCCESS;
2002
adb_getKeysResponseType_reset_return(_getKeysResponseType, env);
2004
_getKeysResponseType->property_return = arg_return;
2005
_getKeysResponseType->is_valid_return = AXIS2_TRUE;
2007
return AXIS2_SUCCESS;
2013
* resetter for return
2015
axis2_status_t AXIS2_CALL
2016
adb_getKeysResponseType_reset_return(
2017
adb_getKeysResponseType_t* _getKeysResponseType,
2018
const axutil_env_t *env)
2022
void *element = NULL;
2024
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2025
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
2028
_getKeysResponseType->is_valid_return = AXIS2_FALSE;
2029
return AXIS2_SUCCESS;
2033
* Check whether return is nill
2035
axis2_bool_t AXIS2_CALL
2036
adb_getKeysResponseType_is_return_nil(
2037
adb_getKeysResponseType_t* _getKeysResponseType,
2038
const axutil_env_t *env)
2040
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2041
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_TRUE);
2043
return !_getKeysResponseType->is_valid_return;
2047
* Set return to nill (currently the same as reset)
2049
axis2_status_t AXIS2_CALL
2050
adb_getKeysResponseType_set_return_nil(
2051
adb_getKeysResponseType_t* _getKeysResponseType,
2052
const axutil_env_t *env)
2054
return adb_getKeysResponseType_reset_return(_getKeysResponseType, env);
2060
* getter for serviceTag.
2062
axis2_char_t* AXIS2_CALL
2063
adb_getKeysResponseType_get_serviceTag(
2064
adb_getKeysResponseType_t* _getKeysResponseType,
2065
const axutil_env_t *env)
2068
AXIS2_ENV_CHECK(env, NULL);
2069
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, NULL);
2072
return _getKeysResponseType->property_serviceTag;
2076
* setter for serviceTag
2078
axis2_status_t AXIS2_CALL
2079
adb_getKeysResponseType_set_serviceTag(
2080
adb_getKeysResponseType_t* _getKeysResponseType,
2081
const axutil_env_t *env,
2082
const axis2_char_t* arg_serviceTag)
2086
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2087
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
2089
if(_getKeysResponseType->is_valid_serviceTag &&
2090
arg_serviceTag == _getKeysResponseType->property_serviceTag)
2093
return AXIS2_SUCCESS;
2096
adb_getKeysResponseType_reset_serviceTag(_getKeysResponseType, env);
2099
if(NULL == arg_serviceTag)
2101
/* We are already done */
2102
return AXIS2_SUCCESS;
2104
_getKeysResponseType->property_serviceTag = (axis2_char_t *)axutil_strdup(env, arg_serviceTag);
2105
if(NULL == _getKeysResponseType->property_serviceTag)
2107
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for serviceTag");
2108
return AXIS2_FAILURE;
2110
_getKeysResponseType->is_valid_serviceTag = AXIS2_TRUE;
2112
return AXIS2_SUCCESS;
2118
* resetter for serviceTag
2120
axis2_status_t AXIS2_CALL
2121
adb_getKeysResponseType_reset_serviceTag(
2122
adb_getKeysResponseType_t* _getKeysResponseType,
2123
const axutil_env_t *env)
2127
void *element = NULL;
2129
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2130
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
2136
if(_getKeysResponseType->property_serviceTag != NULL)
2140
AXIS2_FREE(env-> allocator, _getKeysResponseType->property_serviceTag);
2141
_getKeysResponseType->property_serviceTag = NULL;
2146
_getKeysResponseType->is_valid_serviceTag = AXIS2_FALSE;
2147
return AXIS2_SUCCESS;
2151
* Check whether serviceTag is nill
2153
axis2_bool_t AXIS2_CALL
2154
adb_getKeysResponseType_is_serviceTag_nil(
2155
adb_getKeysResponseType_t* _getKeysResponseType,
2156
const axutil_env_t *env)
2158
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2159
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_TRUE);
2161
return !_getKeysResponseType->is_valid_serviceTag;
2165
* Set serviceTag to nill (currently the same as reset)
2167
axis2_status_t AXIS2_CALL
2168
adb_getKeysResponseType_set_serviceTag_nil(
2169
adb_getKeysResponseType_t* _getKeysResponseType,
2170
const axutil_env_t *env)
2172
return adb_getKeysResponseType_reset_serviceTag(_getKeysResponseType, env);
2178
* getter for CCcert.
2180
axis2_char_t* AXIS2_CALL
2181
adb_getKeysResponseType_get_CCcert(
2182
adb_getKeysResponseType_t* _getKeysResponseType,
2183
const axutil_env_t *env)
2186
AXIS2_ENV_CHECK(env, NULL);
2187
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, NULL);
2190
return _getKeysResponseType->property_CCcert;
2196
axis2_status_t AXIS2_CALL
2197
adb_getKeysResponseType_set_CCcert(
2198
adb_getKeysResponseType_t* _getKeysResponseType,
2199
const axutil_env_t *env,
2200
const axis2_char_t* arg_CCcert)
2204
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2205
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
2207
if(_getKeysResponseType->is_valid_CCcert &&
2208
arg_CCcert == _getKeysResponseType->property_CCcert)
2211
return AXIS2_SUCCESS;
2214
adb_getKeysResponseType_reset_CCcert(_getKeysResponseType, env);
2217
if(NULL == arg_CCcert)
2219
/* We are already done */
2220
return AXIS2_SUCCESS;
2222
_getKeysResponseType->property_CCcert = (axis2_char_t *)axutil_strdup(env, arg_CCcert);
2223
if(NULL == _getKeysResponseType->property_CCcert)
2225
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for CCcert");
2226
return AXIS2_FAILURE;
2228
_getKeysResponseType->is_valid_CCcert = AXIS2_TRUE;
2230
return AXIS2_SUCCESS;
2236
* resetter for CCcert
2238
axis2_status_t AXIS2_CALL
2239
adb_getKeysResponseType_reset_CCcert(
2240
adb_getKeysResponseType_t* _getKeysResponseType,
2241
const axutil_env_t *env)
2245
void *element = NULL;
2247
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2248
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
2254
if(_getKeysResponseType->property_CCcert != NULL)
2258
AXIS2_FREE(env-> allocator, _getKeysResponseType->property_CCcert);
2259
_getKeysResponseType->property_CCcert = NULL;
2264
_getKeysResponseType->is_valid_CCcert = AXIS2_FALSE;
2265
return AXIS2_SUCCESS;
2269
* Check whether CCcert is nill
2271
axis2_bool_t AXIS2_CALL
2272
adb_getKeysResponseType_is_CCcert_nil(
2273
adb_getKeysResponseType_t* _getKeysResponseType,
2274
const axutil_env_t *env)
2276
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2277
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_TRUE);
2279
return !_getKeysResponseType->is_valid_CCcert;
2283
* Set CCcert to nill (currently the same as reset)
2285
axis2_status_t AXIS2_CALL
2286
adb_getKeysResponseType_set_CCcert_nil(
2287
adb_getKeysResponseType_t* _getKeysResponseType,
2288
const axutil_env_t *env)
2290
return adb_getKeysResponseType_reset_CCcert(_getKeysResponseType, env);
2296
* getter for NCcert.
2298
axis2_char_t* AXIS2_CALL
2299
adb_getKeysResponseType_get_NCcert(
2300
adb_getKeysResponseType_t* _getKeysResponseType,
2301
const axutil_env_t *env)
2304
AXIS2_ENV_CHECK(env, NULL);
2305
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, NULL);
2308
return _getKeysResponseType->property_NCcert;
2314
axis2_status_t AXIS2_CALL
2315
adb_getKeysResponseType_set_NCcert(
2316
adb_getKeysResponseType_t* _getKeysResponseType,
2317
const axutil_env_t *env,
2318
const axis2_char_t* arg_NCcert)
2322
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2323
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
2325
if(_getKeysResponseType->is_valid_NCcert &&
2326
arg_NCcert == _getKeysResponseType->property_NCcert)
2329
return AXIS2_SUCCESS;
2332
adb_getKeysResponseType_reset_NCcert(_getKeysResponseType, env);
2335
if(NULL == arg_NCcert)
2337
/* We are already done */
2338
return AXIS2_SUCCESS;
2340
_getKeysResponseType->property_NCcert = (axis2_char_t *)axutil_strdup(env, arg_NCcert);
2341
if(NULL == _getKeysResponseType->property_NCcert)
2343
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for NCcert");
2344
return AXIS2_FAILURE;
2346
_getKeysResponseType->is_valid_NCcert = AXIS2_TRUE;
2348
return AXIS2_SUCCESS;
2354
* resetter for NCcert
2356
axis2_status_t AXIS2_CALL
2357
adb_getKeysResponseType_reset_NCcert(
2358
adb_getKeysResponseType_t* _getKeysResponseType,
2359
const axutil_env_t *env)
2363
void *element = NULL;
2365
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2366
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_FAILURE);
2372
if(_getKeysResponseType->property_NCcert != NULL)
2376
AXIS2_FREE(env-> allocator, _getKeysResponseType->property_NCcert);
2377
_getKeysResponseType->property_NCcert = NULL;
2382
_getKeysResponseType->is_valid_NCcert = AXIS2_FALSE;
2383
return AXIS2_SUCCESS;
2387
* Check whether NCcert is nill
2389
axis2_bool_t AXIS2_CALL
2390
adb_getKeysResponseType_is_NCcert_nil(
2391
adb_getKeysResponseType_t* _getKeysResponseType,
2392
const axutil_env_t *env)
2394
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2395
AXIS2_PARAM_CHECK(env->error, _getKeysResponseType, AXIS2_TRUE);
2397
return !_getKeysResponseType->is_valid_NCcert;
2401
* Set NCcert to nill (currently the same as reset)
2403
axis2_status_t AXIS2_CALL
2404
adb_getKeysResponseType_set_NCcert_nil(
2405
adb_getKeysResponseType_t* _getKeysResponseType,
2406
const axutil_env_t *env)
2408
return adb_getKeysResponseType_reset_NCcert(_getKeysResponseType, env);
added
removed
gatherlog/generated/adb_getKeysResponseType.c
