4
* adb_assignAddressType.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_assignAddressType.h"
13
* This type was generated from the piece of schema that had
14
* name = assignAddressType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_assignAddressType
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_source;
50
axis2_bool_t is_valid_source;
53
axis2_char_t* property_dest;
56
axis2_bool_t is_valid_dest;
63
/************************* Private Function prototypes ********************************/
66
axis2_status_t AXIS2_CALL
67
adb_assignAddressType_set_correlationId_nil(
68
adb_assignAddressType_t* _assignAddressType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_assignAddressType_set_userId_nil(
74
adb_assignAddressType_t* _assignAddressType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_assignAddressType_set_return_nil(
80
adb_assignAddressType_t* _assignAddressType,
81
const axutil_env_t *env);
84
axis2_status_t AXIS2_CALL
85
adb_assignAddressType_set_source_nil(
86
adb_assignAddressType_t* _assignAddressType,
87
const axutil_env_t *env);
90
axis2_status_t AXIS2_CALL
91
adb_assignAddressType_set_dest_nil(
92
adb_assignAddressType_t* _assignAddressType,
93
const axutil_env_t *env);
97
/************************* Function Implmentations ********************************/
98
adb_assignAddressType_t* AXIS2_CALL
99
adb_assignAddressType_create(
100
const axutil_env_t *env)
102
adb_assignAddressType_t *_assignAddressType = NULL;
104
AXIS2_ENV_CHECK(env, NULL);
106
_assignAddressType = (adb_assignAddressType_t *) AXIS2_MALLOC(env->
107
allocator, sizeof(adb_assignAddressType_t));
109
if(NULL == _assignAddressType)
111
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
115
memset(_assignAddressType, 0, sizeof(adb_assignAddressType_t));
117
_assignAddressType->property_correlationId = NULL;
118
_assignAddressType->is_valid_correlationId = AXIS2_FALSE;
119
_assignAddressType->property_userId = NULL;
120
_assignAddressType->is_valid_userId = AXIS2_FALSE;
121
_assignAddressType->property_statusMessage = NULL;
122
_assignAddressType->is_valid_statusMessage = AXIS2_FALSE;
123
_assignAddressType->is_valid_return = AXIS2_FALSE;
124
_assignAddressType->property_source = NULL;
125
_assignAddressType->is_valid_source = AXIS2_FALSE;
126
_assignAddressType->property_dest = NULL;
127
_assignAddressType->is_valid_dest = AXIS2_FALSE;
130
return _assignAddressType;
133
axis2_status_t AXIS2_CALL
134
adb_assignAddressType_free (
135
adb_assignAddressType_t* _assignAddressType,
136
const axutil_env_t *env)
140
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
141
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
143
adb_assignAddressType_reset_correlationId(_assignAddressType, env);
144
adb_assignAddressType_reset_userId(_assignAddressType, env);
145
adb_assignAddressType_reset_statusMessage(_assignAddressType, env);
146
adb_assignAddressType_reset_return(_assignAddressType, env);
147
adb_assignAddressType_reset_source(_assignAddressType, env);
148
adb_assignAddressType_reset_dest(_assignAddressType, env);
151
if(_assignAddressType)
153
AXIS2_FREE(env->allocator, _assignAddressType);
154
_assignAddressType = NULL;
156
return AXIS2_SUCCESS;
162
axis2_status_t AXIS2_CALL
163
adb_assignAddressType_deserialize(
164
adb_assignAddressType_t* _assignAddressType,
165
const axutil_env_t *env,
166
axiom_node_t **dp_parent,
167
axis2_bool_t *dp_is_early_node_valid,
168
axis2_bool_t dont_care_minoccurs)
170
axiom_node_t *parent = *dp_parent;
172
axis2_status_t status = AXIS2_SUCCESS;
174
axis2_char_t* text_value = NULL;
175
axutil_qname_t *qname = NULL;
177
axutil_qname_t *element_qname = NULL;
179
axiom_node_t *first_node = NULL;
180
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
181
axiom_node_t *current_node = NULL;
182
axiom_element_t *current_element = NULL;
184
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
185
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
189
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
191
parent = axiom_node_get_next_sibling(parent, env);
195
/* This should be checked before everything */
196
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
197
"Failed in building adb object for assignAddressType : "
198
"NULL elemenet can not be passed to deserialize");
199
return AXIS2_FAILURE;
203
first_node = axiom_node_get_first_child(parent, env);
209
* building correlationId element
214
current_node = first_node;
215
is_early_node_valid = AXIS2_FALSE;
218
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
220
current_node = axiom_node_get_next_sibling(current_node, env);
222
if(current_node != NULL)
224
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
225
qname = axiom_element_get_qname(current_element, env, current_node);
228
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
232
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
234
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
236
is_early_node_valid = AXIS2_TRUE;
240
text_value = axiom_element_get_text(current_element, env, current_node);
241
if(text_value != NULL)
243
status = adb_assignAddressType_set_correlationId(_assignAddressType, env,
250
* axis2_qname_t *qname = NULL;
251
* axiom_attribute_t *the_attri = NULL;
253
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
254
* the_attri = axiom_element_get_attribute(current_element, env, qname);
256
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
258
axiom_attribute_t *the_attri = NULL;
259
axis2_char_t *attrib_text = NULL;
260
axutil_hash_t *attribute_hash = NULL;
262
attribute_hash = axiom_element_get_all_attributes(current_element, env);
267
axutil_hash_index_t *hi;
271
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
273
axutil_hash_this(hi, &key, NULL, &val);
275
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
277
the_attri = (axiom_attribute_t*)val;
285
attrib_text = axiom_attribute_get_value(the_attri, env);
289
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
290
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
293
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
295
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
296
status = AXIS2_FAILURE;
300
/* after all, we found this is a empty string */
301
status = adb_assignAddressType_set_correlationId(_assignAddressType, env,
306
if(AXIS2_FAILURE == status)
308
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
311
axutil_qname_free(element_qname, env);
313
return AXIS2_FAILURE;
319
axutil_qname_free(element_qname, env);
320
element_qname = NULL;
326
* building userId element
332
* because elements are ordered this works fine
336
if(current_node != NULL && is_early_node_valid)
338
current_node = axiom_node_get_next_sibling(current_node, env);
341
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
343
current_node = axiom_node_get_next_sibling(current_node, env);
345
if(current_node != NULL)
347
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
348
qname = axiom_element_get_qname(current_element, env, current_node);
352
is_early_node_valid = AXIS2_FALSE;
354
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
358
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
360
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
362
is_early_node_valid = AXIS2_TRUE;
366
text_value = axiom_element_get_text(current_element, env, current_node);
367
if(text_value != NULL)
369
status = adb_assignAddressType_set_userId(_assignAddressType, env,
376
* axis2_qname_t *qname = NULL;
377
* axiom_attribute_t *the_attri = NULL;
379
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
380
* the_attri = axiom_element_get_attribute(current_element, env, qname);
382
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
384
axiom_attribute_t *the_attri = NULL;
385
axis2_char_t *attrib_text = NULL;
386
axutil_hash_t *attribute_hash = NULL;
388
attribute_hash = axiom_element_get_all_attributes(current_element, env);
393
axutil_hash_index_t *hi;
397
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
399
axutil_hash_this(hi, &key, NULL, &val);
401
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
403
the_attri = (axiom_attribute_t*)val;
411
attrib_text = axiom_attribute_get_value(the_attri, env);
415
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
416
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
419
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
421
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
422
status = AXIS2_FAILURE;
426
/* after all, we found this is a empty string */
427
status = adb_assignAddressType_set_userId(_assignAddressType, env,
432
if(AXIS2_FAILURE == status)
434
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
437
axutil_qname_free(element_qname, env);
439
return AXIS2_FAILURE;
445
axutil_qname_free(element_qname, env);
446
element_qname = NULL;
452
* building statusMessage element
458
* because elements are ordered this works fine
462
if(current_node != NULL && is_early_node_valid)
464
current_node = axiom_node_get_next_sibling(current_node, env);
467
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
469
current_node = axiom_node_get_next_sibling(current_node, env);
471
if(current_node != NULL)
473
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
474
qname = axiom_element_get_qname(current_element, env, current_node);
478
is_early_node_valid = AXIS2_FALSE;
480
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
484
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
486
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
488
is_early_node_valid = AXIS2_TRUE;
492
text_value = axiom_element_get_text(current_element, env, current_node);
493
if(text_value != NULL)
495
status = adb_assignAddressType_set_statusMessage(_assignAddressType, env,
499
if(AXIS2_FAILURE == status)
501
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
504
axutil_qname_free(element_qname, env);
506
return AXIS2_FAILURE;
512
axutil_qname_free(element_qname, env);
513
element_qname = NULL;
519
* building return element
525
* because elements are ordered this works fine
529
if(current_node != NULL && is_early_node_valid)
531
current_node = axiom_node_get_next_sibling(current_node, env);
534
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
536
current_node = axiom_node_get_next_sibling(current_node, env);
538
if(current_node != NULL)
540
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
541
qname = axiom_element_get_qname(current_element, env, current_node);
545
is_early_node_valid = AXIS2_FALSE;
547
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
551
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
553
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
555
is_early_node_valid = AXIS2_TRUE;
559
text_value = axiom_element_get_text(current_element, env, current_node);
560
if(text_value != NULL)
562
if (!axutil_strcasecmp(text_value , "true"))
564
status = adb_assignAddressType_set_return(_assignAddressType, env,
569
status = adb_assignAddressType_set_return(_assignAddressType, env,
576
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
577
status = AXIS2_FAILURE;
580
if(AXIS2_FAILURE == status)
582
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
585
axutil_qname_free(element_qname, env);
587
return AXIS2_FAILURE;
593
axutil_qname_free(element_qname, env);
594
element_qname = NULL;
600
* building source element
606
* because elements are ordered this works fine
610
if(current_node != NULL && is_early_node_valid)
612
current_node = axiom_node_get_next_sibling(current_node, env);
615
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
617
current_node = axiom_node_get_next_sibling(current_node, env);
619
if(current_node != NULL)
621
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
622
qname = axiom_element_get_qname(current_element, env, current_node);
626
is_early_node_valid = AXIS2_FALSE;
628
element_qname = axutil_qname_create(env, "source", "http://eucalyptus.ucsb.edu/", NULL);
632
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
634
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
636
is_early_node_valid = AXIS2_TRUE;
640
text_value = axiom_element_get_text(current_element, env, current_node);
641
if(text_value != NULL)
643
status = adb_assignAddressType_set_source(_assignAddressType, env,
650
* axis2_qname_t *qname = NULL;
651
* axiom_attribute_t *the_attri = NULL;
653
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
654
* the_attri = axiom_element_get_attribute(current_element, env, qname);
656
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
658
axiom_attribute_t *the_attri = NULL;
659
axis2_char_t *attrib_text = NULL;
660
axutil_hash_t *attribute_hash = NULL;
662
attribute_hash = axiom_element_get_all_attributes(current_element, env);
667
axutil_hash_index_t *hi;
671
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
673
axutil_hash_this(hi, &key, NULL, &val);
675
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
677
the_attri = (axiom_attribute_t*)val;
685
attrib_text = axiom_attribute_get_value(the_attri, env);
689
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
690
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
693
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
695
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element source");
696
status = AXIS2_FAILURE;
700
/* after all, we found this is a empty string */
701
status = adb_assignAddressType_set_source(_assignAddressType, env,
706
if(AXIS2_FAILURE == status)
708
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for source ");
711
axutil_qname_free(element_qname, env);
713
return AXIS2_FAILURE;
717
else if(!dont_care_minoccurs)
721
axutil_qname_free(element_qname, env);
723
/* this is not a nillable element*/
724
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element source missing");
725
return AXIS2_FAILURE;
730
axutil_qname_free(element_qname, env);
731
element_qname = NULL;
737
* building dest element
743
* because elements are ordered this works fine
747
if(current_node != NULL && is_early_node_valid)
749
current_node = axiom_node_get_next_sibling(current_node, env);
752
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
754
current_node = axiom_node_get_next_sibling(current_node, env);
756
if(current_node != NULL)
758
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
759
qname = axiom_element_get_qname(current_element, env, current_node);
763
is_early_node_valid = AXIS2_FALSE;
765
element_qname = axutil_qname_create(env, "dest", "http://eucalyptus.ucsb.edu/", NULL);
769
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
771
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
773
is_early_node_valid = AXIS2_TRUE;
777
text_value = axiom_element_get_text(current_element, env, current_node);
778
if(text_value != NULL)
780
status = adb_assignAddressType_set_dest(_assignAddressType, env,
787
* axis2_qname_t *qname = NULL;
788
* axiom_attribute_t *the_attri = NULL;
790
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
791
* the_attri = axiom_element_get_attribute(current_element, env, qname);
793
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
795
axiom_attribute_t *the_attri = NULL;
796
axis2_char_t *attrib_text = NULL;
797
axutil_hash_t *attribute_hash = NULL;
799
attribute_hash = axiom_element_get_all_attributes(current_element, env);
804
axutil_hash_index_t *hi;
808
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
810
axutil_hash_this(hi, &key, NULL, &val);
812
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
814
the_attri = (axiom_attribute_t*)val;
822
attrib_text = axiom_attribute_get_value(the_attri, env);
826
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
827
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
830
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
832
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element dest");
833
status = AXIS2_FAILURE;
837
/* after all, we found this is a empty string */
838
status = adb_assignAddressType_set_dest(_assignAddressType, env,
843
if(AXIS2_FAILURE == status)
845
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for dest ");
848
axutil_qname_free(element_qname, env);
850
return AXIS2_FAILURE;
854
else if(!dont_care_minoccurs)
858
axutil_qname_free(element_qname, env);
860
/* this is not a nillable element*/
861
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element dest missing");
862
return AXIS2_FAILURE;
867
axutil_qname_free(element_qname, env);
868
element_qname = NULL;
874
axis2_bool_t AXIS2_CALL
875
adb_assignAddressType_is_particle()
884
adb_assignAddressType_declare_parent_namespaces(
885
adb_assignAddressType_t* _assignAddressType,
886
const axutil_env_t *env, axiom_element_t *parent_element,
887
axutil_hash_t *namespaces, int *next_ns_index)
890
/* Here this is an empty function, Nothing to declare */
896
axiom_node_t* AXIS2_CALL
897
adb_assignAddressType_serialize(
898
adb_assignAddressType_t* _assignAddressType,
899
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)
903
axis2_char_t *string_to_stream;
906
axiom_node_t *current_node = NULL;
911
axiom_namespace_t *ns1 = NULL;
913
axis2_char_t *qname_uri = NULL;
914
axis2_char_t *qname_prefix = NULL;
915
axis2_char_t *p_prefix = NULL;
916
axis2_bool_t ns_already_defined;
918
axis2_char_t *text_value_1;
919
axis2_char_t *text_value_1_temp;
921
axis2_char_t *text_value_2;
922
axis2_char_t *text_value_2_temp;
924
axis2_char_t *text_value_3;
925
axis2_char_t *text_value_3_temp;
927
axis2_char_t text_value_4[64];
929
axis2_char_t *text_value_5;
930
axis2_char_t *text_value_5_temp;
932
axis2_char_t *text_value_6;
933
axis2_char_t *text_value_6_temp;
935
axis2_char_t *start_input_str = NULL;
936
axis2_char_t *end_input_str = NULL;
937
unsigned int start_input_str_len = 0;
938
unsigned int end_input_str_len = 0;
941
axiom_data_source_t *data_source = NULL;
942
axutil_stream_t *stream = NULL;
946
AXIS2_ENV_CHECK(env, NULL);
947
AXIS2_PARAM_CHECK(env->error, _assignAddressType, NULL);
950
current_node = parent;
951
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
954
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
958
if(!parent_tag_closed)
961
string_to_stream = ">";
962
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
967
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
969
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
970
sprintf(p_prefix, "n%d", (*next_ns_index)++);
971
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
973
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
974
"http://eucalyptus.ucsb.edu/",
979
if (!_assignAddressType->is_valid_correlationId)
982
/* no need to complain for minoccurs=0 element */
988
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
989
(4 + axutil_strlen(p_prefix) +
990
axutil_strlen("correlationId")));
992
/* axutil_strlen("<:>") + 1 = 4 */
993
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
994
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
995
/* axutil_strlen("</:>") + 1 = 5 */
1003
* parsing correlationId element
1008
sprintf(start_input_str, "<%s%scorrelationId>",
1009
p_prefix?p_prefix:"",
1010
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1012
start_input_str_len = axutil_strlen(start_input_str);
1013
sprintf(end_input_str, "</%s%scorrelationId>",
1014
p_prefix?p_prefix:"",
1015
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1016
end_input_str_len = axutil_strlen(end_input_str);
1018
text_value_1 = _assignAddressType->property_correlationId;
1020
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1023
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1024
if (text_value_1_temp)
1026
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1027
AXIS2_FREE(env->allocator, text_value_1_temp);
1031
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1034
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1037
AXIS2_FREE(env->allocator,start_input_str);
1038
AXIS2_FREE(env->allocator,end_input_str);
1042
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1044
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1045
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1046
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1048
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1049
"http://eucalyptus.ucsb.edu/",
1054
if (!_assignAddressType->is_valid_userId)
1057
/* no need to complain for minoccurs=0 element */
1063
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1064
(4 + axutil_strlen(p_prefix) +
1065
axutil_strlen("userId")));
1067
/* axutil_strlen("<:>") + 1 = 4 */
1068
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1069
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1070
/* axutil_strlen("</:>") + 1 = 5 */
1078
* parsing userId element
1083
sprintf(start_input_str, "<%s%suserId>",
1084
p_prefix?p_prefix:"",
1085
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1087
start_input_str_len = axutil_strlen(start_input_str);
1088
sprintf(end_input_str, "</%s%suserId>",
1089
p_prefix?p_prefix:"",
1090
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1091
end_input_str_len = axutil_strlen(end_input_str);
1093
text_value_2 = _assignAddressType->property_userId;
1095
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1098
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1099
if (text_value_2_temp)
1101
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1102
AXIS2_FREE(env->allocator, text_value_2_temp);
1106
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1109
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1112
AXIS2_FREE(env->allocator,start_input_str);
1113
AXIS2_FREE(env->allocator,end_input_str);
1117
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1119
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1120
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1121
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1123
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1124
"http://eucalyptus.ucsb.edu/",
1129
if (!_assignAddressType->is_valid_statusMessage)
1132
/* no need to complain for minoccurs=0 element */
1138
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1139
(4 + axutil_strlen(p_prefix) +
1140
axutil_strlen("statusMessage")));
1142
/* axutil_strlen("<:>") + 1 = 4 */
1143
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1144
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1145
/* axutil_strlen("</:>") + 1 = 5 */
1153
* parsing statusMessage element
1158
sprintf(start_input_str, "<%s%sstatusMessage>",
1159
p_prefix?p_prefix:"",
1160
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1162
start_input_str_len = axutil_strlen(start_input_str);
1163
sprintf(end_input_str, "</%s%sstatusMessage>",
1164
p_prefix?p_prefix:"",
1165
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1166
end_input_str_len = axutil_strlen(end_input_str);
1168
text_value_3 = _assignAddressType->property_statusMessage;
1170
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1173
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1174
if (text_value_3_temp)
1176
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1177
AXIS2_FREE(env->allocator, text_value_3_temp);
1181
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1184
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1187
AXIS2_FREE(env->allocator,start_input_str);
1188
AXIS2_FREE(env->allocator,end_input_str);
1192
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1194
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1195
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1196
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1198
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1199
"http://eucalyptus.ucsb.edu/",
1204
if (!_assignAddressType->is_valid_return)
1207
/* no need to complain for minoccurs=0 element */
1213
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1214
(4 + axutil_strlen(p_prefix) +
1215
axutil_strlen("return")));
1217
/* axutil_strlen("<:>") + 1 = 4 */
1218
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1219
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1220
/* axutil_strlen("</:>") + 1 = 5 */
1228
* parsing return element
1233
sprintf(start_input_str, "<%s%sreturn>",
1234
p_prefix?p_prefix:"",
1235
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1237
start_input_str_len = axutil_strlen(start_input_str);
1238
sprintf(end_input_str, "</%s%sreturn>",
1239
p_prefix?p_prefix:"",
1240
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1241
end_input_str_len = axutil_strlen(end_input_str);
1243
strcpy(text_value_4, (_assignAddressType->property_return)?"true":"false");
1245
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1247
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1249
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1252
AXIS2_FREE(env->allocator,start_input_str);
1253
AXIS2_FREE(env->allocator,end_input_str);
1257
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1259
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1260
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1261
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1263
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1264
"http://eucalyptus.ucsb.edu/",
1269
if (!_assignAddressType->is_valid_source)
1273
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property source");
1279
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1280
(4 + axutil_strlen(p_prefix) +
1281
axutil_strlen("source")));
1283
/* axutil_strlen("<:>") + 1 = 4 */
1284
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1285
(5 + axutil_strlen(p_prefix) + axutil_strlen("source")));
1286
/* axutil_strlen("</:>") + 1 = 5 */
1294
* parsing source element
1299
sprintf(start_input_str, "<%s%ssource>",
1300
p_prefix?p_prefix:"",
1301
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1303
start_input_str_len = axutil_strlen(start_input_str);
1304
sprintf(end_input_str, "</%s%ssource>",
1305
p_prefix?p_prefix:"",
1306
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1307
end_input_str_len = axutil_strlen(end_input_str);
1309
text_value_5 = _assignAddressType->property_source;
1311
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1314
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1315
if (text_value_5_temp)
1317
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1318
AXIS2_FREE(env->allocator, text_value_5_temp);
1322
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1325
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1328
AXIS2_FREE(env->allocator,start_input_str);
1329
AXIS2_FREE(env->allocator,end_input_str);
1333
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1335
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1336
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1337
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1339
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1340
"http://eucalyptus.ucsb.edu/",
1345
if (!_assignAddressType->is_valid_dest)
1349
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property dest");
1355
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1356
(4 + axutil_strlen(p_prefix) +
1357
axutil_strlen("dest")));
1359
/* axutil_strlen("<:>") + 1 = 4 */
1360
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1361
(5 + axutil_strlen(p_prefix) + axutil_strlen("dest")));
1362
/* axutil_strlen("</:>") + 1 = 5 */
1370
* parsing dest element
1375
sprintf(start_input_str, "<%s%sdest>",
1376
p_prefix?p_prefix:"",
1377
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1379
start_input_str_len = axutil_strlen(start_input_str);
1380
sprintf(end_input_str, "</%s%sdest>",
1381
p_prefix?p_prefix:"",
1382
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1383
end_input_str_len = axutil_strlen(end_input_str);
1385
text_value_6 = _assignAddressType->property_dest;
1387
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1390
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1391
if (text_value_6_temp)
1393
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1394
AXIS2_FREE(env->allocator, text_value_6_temp);
1398
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1401
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1404
AXIS2_FREE(env->allocator,start_input_str);
1405
AXIS2_FREE(env->allocator,end_input_str);
1417
* getter for correlationId.
1419
axis2_char_t* AXIS2_CALL
1420
adb_assignAddressType_get_correlationId(
1421
adb_assignAddressType_t* _assignAddressType,
1422
const axutil_env_t *env)
1425
AXIS2_ENV_CHECK(env, NULL);
1426
AXIS2_PARAM_CHECK(env->error, _assignAddressType, NULL);
1429
return _assignAddressType->property_correlationId;
1433
* setter for correlationId
1435
axis2_status_t AXIS2_CALL
1436
adb_assignAddressType_set_correlationId(
1437
adb_assignAddressType_t* _assignAddressType,
1438
const axutil_env_t *env,
1439
const axis2_char_t* arg_correlationId)
1443
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1444
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1446
if(_assignAddressType->is_valid_correlationId &&
1447
arg_correlationId == _assignAddressType->property_correlationId)
1450
return AXIS2_SUCCESS;
1453
adb_assignAddressType_reset_correlationId(_assignAddressType, env);
1456
if(NULL == arg_correlationId)
1458
/* We are already done */
1459
return AXIS2_SUCCESS;
1461
_assignAddressType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1462
if(NULL == _assignAddressType->property_correlationId)
1464
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1465
return AXIS2_FAILURE;
1467
_assignAddressType->is_valid_correlationId = AXIS2_TRUE;
1469
return AXIS2_SUCCESS;
1475
* resetter for correlationId
1477
axis2_status_t AXIS2_CALL
1478
adb_assignAddressType_reset_correlationId(
1479
adb_assignAddressType_t* _assignAddressType,
1480
const axutil_env_t *env)
1484
void *element = NULL;
1486
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1487
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1493
if(_assignAddressType->property_correlationId != NULL)
1497
AXIS2_FREE(env-> allocator, _assignAddressType->property_correlationId);
1498
_assignAddressType->property_correlationId = NULL;
1503
_assignAddressType->is_valid_correlationId = AXIS2_FALSE;
1504
return AXIS2_SUCCESS;
1508
* Check whether correlationId is nill
1510
axis2_bool_t AXIS2_CALL
1511
adb_assignAddressType_is_correlationId_nil(
1512
adb_assignAddressType_t* _assignAddressType,
1513
const axutil_env_t *env)
1515
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1516
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_TRUE);
1518
return !_assignAddressType->is_valid_correlationId;
1522
* Set correlationId to nill (currently the same as reset)
1524
axis2_status_t AXIS2_CALL
1525
adb_assignAddressType_set_correlationId_nil(
1526
adb_assignAddressType_t* _assignAddressType,
1527
const axutil_env_t *env)
1529
return adb_assignAddressType_reset_correlationId(_assignAddressType, env);
1535
* getter for userId.
1537
axis2_char_t* AXIS2_CALL
1538
adb_assignAddressType_get_userId(
1539
adb_assignAddressType_t* _assignAddressType,
1540
const axutil_env_t *env)
1543
AXIS2_ENV_CHECK(env, NULL);
1544
AXIS2_PARAM_CHECK(env->error, _assignAddressType, NULL);
1547
return _assignAddressType->property_userId;
1553
axis2_status_t AXIS2_CALL
1554
adb_assignAddressType_set_userId(
1555
adb_assignAddressType_t* _assignAddressType,
1556
const axutil_env_t *env,
1557
const axis2_char_t* arg_userId)
1561
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1562
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1564
if(_assignAddressType->is_valid_userId &&
1565
arg_userId == _assignAddressType->property_userId)
1568
return AXIS2_SUCCESS;
1571
adb_assignAddressType_reset_userId(_assignAddressType, env);
1574
if(NULL == arg_userId)
1576
/* We are already done */
1577
return AXIS2_SUCCESS;
1579
_assignAddressType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1580
if(NULL == _assignAddressType->property_userId)
1582
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1583
return AXIS2_FAILURE;
1585
_assignAddressType->is_valid_userId = AXIS2_TRUE;
1587
return AXIS2_SUCCESS;
1593
* resetter for userId
1595
axis2_status_t AXIS2_CALL
1596
adb_assignAddressType_reset_userId(
1597
adb_assignAddressType_t* _assignAddressType,
1598
const axutil_env_t *env)
1602
void *element = NULL;
1604
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1605
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1611
if(_assignAddressType->property_userId != NULL)
1615
AXIS2_FREE(env-> allocator, _assignAddressType->property_userId);
1616
_assignAddressType->property_userId = NULL;
1621
_assignAddressType->is_valid_userId = AXIS2_FALSE;
1622
return AXIS2_SUCCESS;
1626
* Check whether userId is nill
1628
axis2_bool_t AXIS2_CALL
1629
adb_assignAddressType_is_userId_nil(
1630
adb_assignAddressType_t* _assignAddressType,
1631
const axutil_env_t *env)
1633
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1634
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_TRUE);
1636
return !_assignAddressType->is_valid_userId;
1640
* Set userId to nill (currently the same as reset)
1642
axis2_status_t AXIS2_CALL
1643
adb_assignAddressType_set_userId_nil(
1644
adb_assignAddressType_t* _assignAddressType,
1645
const axutil_env_t *env)
1647
return adb_assignAddressType_reset_userId(_assignAddressType, env);
1653
* getter for statusMessage.
1655
axis2_char_t* AXIS2_CALL
1656
adb_assignAddressType_get_statusMessage(
1657
adb_assignAddressType_t* _assignAddressType,
1658
const axutil_env_t *env)
1661
AXIS2_ENV_CHECK(env, NULL);
1662
AXIS2_PARAM_CHECK(env->error, _assignAddressType, NULL);
1665
return _assignAddressType->property_statusMessage;
1669
* setter for statusMessage
1671
axis2_status_t AXIS2_CALL
1672
adb_assignAddressType_set_statusMessage(
1673
adb_assignAddressType_t* _assignAddressType,
1674
const axutil_env_t *env,
1675
const axis2_char_t* arg_statusMessage)
1679
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1680
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1682
if(_assignAddressType->is_valid_statusMessage &&
1683
arg_statusMessage == _assignAddressType->property_statusMessage)
1686
return AXIS2_SUCCESS;
1689
adb_assignAddressType_reset_statusMessage(_assignAddressType, env);
1692
if(NULL == arg_statusMessage)
1694
/* We are already done */
1695
return AXIS2_SUCCESS;
1697
_assignAddressType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1698
if(NULL == _assignAddressType->property_statusMessage)
1700
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1701
return AXIS2_FAILURE;
1703
_assignAddressType->is_valid_statusMessage = AXIS2_TRUE;
1705
return AXIS2_SUCCESS;
1711
* resetter for statusMessage
1713
axis2_status_t AXIS2_CALL
1714
adb_assignAddressType_reset_statusMessage(
1715
adb_assignAddressType_t* _assignAddressType,
1716
const axutil_env_t *env)
1720
void *element = NULL;
1722
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1723
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1729
if(_assignAddressType->property_statusMessage != NULL)
1733
AXIS2_FREE(env-> allocator, _assignAddressType->property_statusMessage);
1734
_assignAddressType->property_statusMessage = NULL;
1739
_assignAddressType->is_valid_statusMessage = AXIS2_FALSE;
1740
return AXIS2_SUCCESS;
1744
* Check whether statusMessage is nill
1746
axis2_bool_t AXIS2_CALL
1747
adb_assignAddressType_is_statusMessage_nil(
1748
adb_assignAddressType_t* _assignAddressType,
1749
const axutil_env_t *env)
1751
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1752
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_TRUE);
1754
return !_assignAddressType->is_valid_statusMessage;
1758
* Set statusMessage to nill (currently the same as reset)
1760
axis2_status_t AXIS2_CALL
1761
adb_assignAddressType_set_statusMessage_nil(
1762
adb_assignAddressType_t* _assignAddressType,
1763
const axutil_env_t *env)
1765
return adb_assignAddressType_reset_statusMessage(_assignAddressType, env);
1771
* getter for return.
1773
axis2_bool_t AXIS2_CALL
1774
adb_assignAddressType_get_return(
1775
adb_assignAddressType_t* _assignAddressType,
1776
const axutil_env_t *env)
1779
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1780
AXIS2_PARAM_CHECK(env->error, _assignAddressType, (axis2_bool_t)0);
1783
return _assignAddressType->property_return;
1789
axis2_status_t AXIS2_CALL
1790
adb_assignAddressType_set_return(
1791
adb_assignAddressType_t* _assignAddressType,
1792
const axutil_env_t *env,
1793
axis2_bool_t arg_return)
1797
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1798
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1800
if(_assignAddressType->is_valid_return &&
1801
arg_return == _assignAddressType->property_return)
1804
return AXIS2_SUCCESS;
1807
adb_assignAddressType_reset_return(_assignAddressType, env);
1809
_assignAddressType->property_return = arg_return;
1810
_assignAddressType->is_valid_return = AXIS2_TRUE;
1812
return AXIS2_SUCCESS;
1818
* resetter for return
1820
axis2_status_t AXIS2_CALL
1821
adb_assignAddressType_reset_return(
1822
adb_assignAddressType_t* _assignAddressType,
1823
const axutil_env_t *env)
1827
void *element = NULL;
1829
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1830
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1833
_assignAddressType->is_valid_return = AXIS2_FALSE;
1834
return AXIS2_SUCCESS;
1838
* Check whether return is nill
1840
axis2_bool_t AXIS2_CALL
1841
adb_assignAddressType_is_return_nil(
1842
adb_assignAddressType_t* _assignAddressType,
1843
const axutil_env_t *env)
1845
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1846
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_TRUE);
1848
return !_assignAddressType->is_valid_return;
1852
* Set return to nill (currently the same as reset)
1854
axis2_status_t AXIS2_CALL
1855
adb_assignAddressType_set_return_nil(
1856
adb_assignAddressType_t* _assignAddressType,
1857
const axutil_env_t *env)
1859
return adb_assignAddressType_reset_return(_assignAddressType, env);
1865
* getter for source.
1867
axis2_char_t* AXIS2_CALL
1868
adb_assignAddressType_get_source(
1869
adb_assignAddressType_t* _assignAddressType,
1870
const axutil_env_t *env)
1873
AXIS2_ENV_CHECK(env, NULL);
1874
AXIS2_PARAM_CHECK(env->error, _assignAddressType, NULL);
1877
return _assignAddressType->property_source;
1883
axis2_status_t AXIS2_CALL
1884
adb_assignAddressType_set_source(
1885
adb_assignAddressType_t* _assignAddressType,
1886
const axutil_env_t *env,
1887
const axis2_char_t* arg_source)
1891
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1892
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1894
if(_assignAddressType->is_valid_source &&
1895
arg_source == _assignAddressType->property_source)
1898
return AXIS2_SUCCESS;
1902
if(NULL == arg_source)
1904
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "source is being set to NULL, but it is not a nullable element");
1905
return AXIS2_FAILURE;
1907
adb_assignAddressType_reset_source(_assignAddressType, env);
1910
if(NULL == arg_source)
1912
/* We are already done */
1913
return AXIS2_SUCCESS;
1915
_assignAddressType->property_source = (axis2_char_t *)axutil_strdup(env, arg_source);
1916
if(NULL == _assignAddressType->property_source)
1918
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for source");
1919
return AXIS2_FAILURE;
1921
_assignAddressType->is_valid_source = AXIS2_TRUE;
1923
return AXIS2_SUCCESS;
1929
* resetter for source
1931
axis2_status_t AXIS2_CALL
1932
adb_assignAddressType_reset_source(
1933
adb_assignAddressType_t* _assignAddressType,
1934
const axutil_env_t *env)
1938
void *element = NULL;
1940
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1941
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
1947
if(_assignAddressType->property_source != NULL)
1951
AXIS2_FREE(env-> allocator, _assignAddressType->property_source);
1952
_assignAddressType->property_source = NULL;
1957
_assignAddressType->is_valid_source = AXIS2_FALSE;
1958
return AXIS2_SUCCESS;
1962
* Check whether source is nill
1964
axis2_bool_t AXIS2_CALL
1965
adb_assignAddressType_is_source_nil(
1966
adb_assignAddressType_t* _assignAddressType,
1967
const axutil_env_t *env)
1969
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1970
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_TRUE);
1972
return !_assignAddressType->is_valid_source;
1976
* Set source to nill (currently the same as reset)
1978
axis2_status_t AXIS2_CALL
1979
adb_assignAddressType_set_source_nil(
1980
adb_assignAddressType_t* _assignAddressType,
1981
const axutil_env_t *env)
1983
return adb_assignAddressType_reset_source(_assignAddressType, env);
1991
axis2_char_t* AXIS2_CALL
1992
adb_assignAddressType_get_dest(
1993
adb_assignAddressType_t* _assignAddressType,
1994
const axutil_env_t *env)
1997
AXIS2_ENV_CHECK(env, NULL);
1998
AXIS2_PARAM_CHECK(env->error, _assignAddressType, NULL);
2001
return _assignAddressType->property_dest;
2007
axis2_status_t AXIS2_CALL
2008
adb_assignAddressType_set_dest(
2009
adb_assignAddressType_t* _assignAddressType,
2010
const axutil_env_t *env,
2011
const axis2_char_t* arg_dest)
2015
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2016
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
2018
if(_assignAddressType->is_valid_dest &&
2019
arg_dest == _assignAddressType->property_dest)
2022
return AXIS2_SUCCESS;
2026
if(NULL == arg_dest)
2028
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "dest is being set to NULL, but it is not a nullable element");
2029
return AXIS2_FAILURE;
2031
adb_assignAddressType_reset_dest(_assignAddressType, env);
2034
if(NULL == arg_dest)
2036
/* We are already done */
2037
return AXIS2_SUCCESS;
2039
_assignAddressType->property_dest = (axis2_char_t *)axutil_strdup(env, arg_dest);
2040
if(NULL == _assignAddressType->property_dest)
2042
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for dest");
2043
return AXIS2_FAILURE;
2045
_assignAddressType->is_valid_dest = AXIS2_TRUE;
2047
return AXIS2_SUCCESS;
2055
axis2_status_t AXIS2_CALL
2056
adb_assignAddressType_reset_dest(
2057
adb_assignAddressType_t* _assignAddressType,
2058
const axutil_env_t *env)
2062
void *element = NULL;
2064
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2065
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_FAILURE);
2071
if(_assignAddressType->property_dest != NULL)
2075
AXIS2_FREE(env-> allocator, _assignAddressType->property_dest);
2076
_assignAddressType->property_dest = NULL;
2081
_assignAddressType->is_valid_dest = AXIS2_FALSE;
2082
return AXIS2_SUCCESS;
2086
* Check whether dest is nill
2088
axis2_bool_t AXIS2_CALL
2089
adb_assignAddressType_is_dest_nil(
2090
adb_assignAddressType_t* _assignAddressType,
2091
const axutil_env_t *env)
2093
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2094
AXIS2_PARAM_CHECK(env->error, _assignAddressType, AXIS2_TRUE);
2096
return !_assignAddressType->is_valid_dest;
2100
* Set dest to nill (currently the same as reset)
2102
axis2_status_t AXIS2_CALL
2103
adb_assignAddressType_set_dest_nil(
2104
adb_assignAddressType_t* _assignAddressType,
2105
const axutil_env_t *env)
2107
return adb_assignAddressType_reset_dest(_assignAddressType, env);
added
removed
cluster/generated/adb_assignAddressType.c
