4
* adb_ncStartNetworkResponseType.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_ncStartNetworkResponseType.h"
13
* This type was generated from the piece of schema that had
14
* name = ncStartNetworkResponseType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_ncStartNetworkResponseType
23
axis2_char_t* property_correlationId;
26
axis2_bool_t is_valid_correlationId;
29
axis2_char_t* property_userId;
32
axis2_bool_t is_valid_userId;
35
axis2_bool_t property_return;
38
axis2_bool_t is_valid_return;
41
axis2_char_t* property_nodeName;
44
axis2_bool_t is_valid_nodeName;
47
int property_statusMessage;
50
axis2_bool_t is_valid_statusMessage;
53
axis2_char_t* property_networkStatus;
56
axis2_bool_t is_valid_networkStatus;
63
/************************* Private Function prototypes ********************************/
66
axis2_status_t AXIS2_CALL
67
adb_ncStartNetworkResponseType_set_userId_nil(
68
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_ncStartNetworkResponseType_set_return_nil(
74
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_ncStartNetworkResponseType_set_networkStatus_nil(
80
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
81
const axutil_env_t *env);
85
/************************* Function Implmentations ********************************/
86
adb_ncStartNetworkResponseType_t* AXIS2_CALL
87
adb_ncStartNetworkResponseType_create(
88
const axutil_env_t *env)
90
adb_ncStartNetworkResponseType_t *_ncStartNetworkResponseType = NULL;
92
AXIS2_ENV_CHECK(env, NULL);
94
_ncStartNetworkResponseType = (adb_ncStartNetworkResponseType_t *) AXIS2_MALLOC(env->
95
allocator, sizeof(adb_ncStartNetworkResponseType_t));
97
if(NULL == _ncStartNetworkResponseType)
99
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
103
memset(_ncStartNetworkResponseType, 0, sizeof(adb_ncStartNetworkResponseType_t));
105
_ncStartNetworkResponseType->property_correlationId = NULL;
106
_ncStartNetworkResponseType->is_valid_correlationId = AXIS2_FALSE;
107
_ncStartNetworkResponseType->property_userId = NULL;
108
_ncStartNetworkResponseType->is_valid_userId = AXIS2_FALSE;
109
_ncStartNetworkResponseType->is_valid_return = AXIS2_FALSE;
110
_ncStartNetworkResponseType->property_nodeName = NULL;
111
_ncStartNetworkResponseType->is_valid_nodeName = AXIS2_FALSE;
112
_ncStartNetworkResponseType->is_valid_statusMessage = AXIS2_FALSE;
113
_ncStartNetworkResponseType->property_networkStatus = NULL;
114
_ncStartNetworkResponseType->is_valid_networkStatus = AXIS2_FALSE;
117
return _ncStartNetworkResponseType;
120
axis2_status_t AXIS2_CALL
121
adb_ncStartNetworkResponseType_free (
122
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
123
const axutil_env_t *env)
127
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
128
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
130
adb_ncStartNetworkResponseType_reset_correlationId(_ncStartNetworkResponseType, env);
131
adb_ncStartNetworkResponseType_reset_userId(_ncStartNetworkResponseType, env);
132
adb_ncStartNetworkResponseType_reset_return(_ncStartNetworkResponseType, env);
133
adb_ncStartNetworkResponseType_reset_nodeName(_ncStartNetworkResponseType, env);
134
adb_ncStartNetworkResponseType_reset_statusMessage(_ncStartNetworkResponseType, env);
135
adb_ncStartNetworkResponseType_reset_networkStatus(_ncStartNetworkResponseType, env);
138
if(_ncStartNetworkResponseType)
140
AXIS2_FREE(env->allocator, _ncStartNetworkResponseType);
141
_ncStartNetworkResponseType = NULL;
143
return AXIS2_SUCCESS;
149
axis2_status_t AXIS2_CALL
150
adb_ncStartNetworkResponseType_deserialize(
151
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
152
const axutil_env_t *env,
153
axiom_node_t **dp_parent,
154
axis2_bool_t *dp_is_early_node_valid,
155
axis2_bool_t dont_care_minoccurs)
157
axiom_node_t *parent = *dp_parent;
159
axis2_status_t status = AXIS2_SUCCESS;
161
axis2_char_t* text_value = NULL;
162
axutil_qname_t *qname = NULL;
164
axutil_qname_t *element_qname = NULL;
166
axiom_node_t *first_node = NULL;
167
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
168
axiom_node_t *current_node = NULL;
169
axiom_element_t *current_element = NULL;
171
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
172
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
176
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
178
parent = axiom_node_get_next_sibling(parent, env);
182
/* This should be checked before everything */
183
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
184
"Failed in building adb object for ncStartNetworkResponseType : "
185
"NULL elemenet can not be passed to deserialize");
186
return AXIS2_FAILURE;
190
first_node = axiom_node_get_first_child(parent, env);
196
* building correlationId element
201
current_node = first_node;
202
is_early_node_valid = AXIS2_FALSE;
205
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
207
current_node = axiom_node_get_next_sibling(current_node, env);
209
if(current_node != NULL)
211
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
212
qname = axiom_element_get_qname(current_element, env, current_node);
215
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
219
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
221
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
223
is_early_node_valid = AXIS2_TRUE;
227
text_value = axiom_element_get_text(current_element, env, current_node);
228
if(text_value != NULL)
230
status = adb_ncStartNetworkResponseType_set_correlationId(_ncStartNetworkResponseType, env,
234
if(AXIS2_FAILURE == status)
236
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
239
axutil_qname_free(element_qname, env);
241
return AXIS2_FAILURE;
247
axutil_qname_free(element_qname, env);
248
element_qname = NULL;
254
* building userId element
260
* because elements are ordered this works fine
264
if(current_node != NULL && is_early_node_valid)
266
current_node = axiom_node_get_next_sibling(current_node, env);
269
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
271
current_node = axiom_node_get_next_sibling(current_node, env);
273
if(current_node != NULL)
275
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
276
qname = axiom_element_get_qname(current_element, env, current_node);
280
is_early_node_valid = AXIS2_FALSE;
282
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
286
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
288
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
290
is_early_node_valid = AXIS2_TRUE;
294
text_value = axiom_element_get_text(current_element, env, current_node);
295
if(text_value != NULL)
297
status = adb_ncStartNetworkResponseType_set_userId(_ncStartNetworkResponseType, env,
304
* axis2_qname_t *qname = NULL;
305
* axiom_attribute_t *the_attri = NULL;
307
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
308
* the_attri = axiom_element_get_attribute(current_element, env, qname);
310
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
312
axiom_attribute_t *the_attri = NULL;
313
axis2_char_t *attrib_text = NULL;
314
axutil_hash_t *attribute_hash = NULL;
316
attribute_hash = axiom_element_get_all_attributes(current_element, env);
321
axutil_hash_index_t *hi;
325
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
327
axutil_hash_this(hi, &key, NULL, &val);
329
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
331
the_attri = (axiom_attribute_t*)val;
339
attrib_text = axiom_attribute_get_value(the_attri, env);
343
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
344
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
347
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
349
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
350
status = AXIS2_FAILURE;
354
/* after all, we found this is a empty string */
355
status = adb_ncStartNetworkResponseType_set_userId(_ncStartNetworkResponseType, env,
360
if(AXIS2_FAILURE == status)
362
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
365
axutil_qname_free(element_qname, env);
367
return AXIS2_FAILURE;
373
axutil_qname_free(element_qname, env);
374
element_qname = NULL;
380
* building return element
386
* because elements are ordered this works fine
390
if(current_node != NULL && is_early_node_valid)
392
current_node = axiom_node_get_next_sibling(current_node, env);
395
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
397
current_node = axiom_node_get_next_sibling(current_node, env);
399
if(current_node != NULL)
401
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
402
qname = axiom_element_get_qname(current_element, env, current_node);
406
is_early_node_valid = AXIS2_FALSE;
408
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
412
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
414
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
416
is_early_node_valid = AXIS2_TRUE;
420
text_value = axiom_element_get_text(current_element, env, current_node);
421
if(text_value != NULL)
423
if (!axutil_strcasecmp(text_value , "true"))
425
status = adb_ncStartNetworkResponseType_set_return(_ncStartNetworkResponseType, env,
430
status = adb_ncStartNetworkResponseType_set_return(_ncStartNetworkResponseType, env,
437
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
438
status = AXIS2_FAILURE;
441
if(AXIS2_FAILURE == status)
443
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
446
axutil_qname_free(element_qname, env);
448
return AXIS2_FAILURE;
454
axutil_qname_free(element_qname, env);
455
element_qname = NULL;
461
* building nodeName element
467
* because elements are ordered this works fine
471
if(current_node != NULL && is_early_node_valid)
473
current_node = axiom_node_get_next_sibling(current_node, env);
476
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
478
current_node = axiom_node_get_next_sibling(current_node, env);
480
if(current_node != NULL)
482
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
483
qname = axiom_element_get_qname(current_element, env, current_node);
487
is_early_node_valid = AXIS2_FALSE;
489
element_qname = axutil_qname_create(env, "nodeName", "http://eucalyptus.ucsb.edu/", NULL);
493
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
495
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
497
is_early_node_valid = AXIS2_TRUE;
501
text_value = axiom_element_get_text(current_element, env, current_node);
502
if(text_value != NULL)
504
status = adb_ncStartNetworkResponseType_set_nodeName(_ncStartNetworkResponseType, env,
508
if(AXIS2_FAILURE == status)
510
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeName ");
513
axutil_qname_free(element_qname, env);
515
return AXIS2_FAILURE;
521
axutil_qname_free(element_qname, env);
522
element_qname = NULL;
528
* building statusMessage element
534
* because elements are ordered this works fine
538
if(current_node != NULL && is_early_node_valid)
540
current_node = axiom_node_get_next_sibling(current_node, env);
543
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
545
current_node = axiom_node_get_next_sibling(current_node, env);
547
if(current_node != NULL)
549
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
550
qname = axiom_element_get_qname(current_element, env, current_node);
554
is_early_node_valid = AXIS2_FALSE;
556
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
560
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
562
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
564
is_early_node_valid = AXIS2_TRUE;
568
text_value = axiom_element_get_text(current_element, env, current_node);
569
if(text_value != NULL)
571
status = adb_ncStartNetworkResponseType_set_statusMessage(_ncStartNetworkResponseType, env,
575
if(AXIS2_FAILURE == status)
577
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
580
axutil_qname_free(element_qname, env);
582
return AXIS2_FAILURE;
588
axutil_qname_free(element_qname, env);
589
element_qname = NULL;
595
* building networkStatus element
601
* because elements are ordered this works fine
605
if(current_node != NULL && is_early_node_valid)
607
current_node = axiom_node_get_next_sibling(current_node, env);
610
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
612
current_node = axiom_node_get_next_sibling(current_node, env);
614
if(current_node != NULL)
616
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
617
qname = axiom_element_get_qname(current_element, env, current_node);
621
is_early_node_valid = AXIS2_FALSE;
623
element_qname = axutil_qname_create(env, "networkStatus", "http://eucalyptus.ucsb.edu/", NULL);
627
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
629
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
631
is_early_node_valid = AXIS2_TRUE;
635
text_value = axiom_element_get_text(current_element, env, current_node);
636
if(text_value != NULL)
638
status = adb_ncStartNetworkResponseType_set_networkStatus(_ncStartNetworkResponseType, env,
645
* axis2_qname_t *qname = NULL;
646
* axiom_attribute_t *the_attri = NULL;
648
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
649
* the_attri = axiom_element_get_attribute(current_element, env, qname);
651
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
653
axiom_attribute_t *the_attri = NULL;
654
axis2_char_t *attrib_text = NULL;
655
axutil_hash_t *attribute_hash = NULL;
657
attribute_hash = axiom_element_get_all_attributes(current_element, env);
662
axutil_hash_index_t *hi;
666
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
668
axutil_hash_this(hi, &key, NULL, &val);
670
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
672
the_attri = (axiom_attribute_t*)val;
680
attrib_text = axiom_attribute_get_value(the_attri, env);
684
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
685
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
688
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
690
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element networkStatus");
691
status = AXIS2_FAILURE;
695
/* after all, we found this is a empty string */
696
status = adb_ncStartNetworkResponseType_set_networkStatus(_ncStartNetworkResponseType, env,
701
if(AXIS2_FAILURE == status)
703
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for networkStatus ");
706
axutil_qname_free(element_qname, env);
708
return AXIS2_FAILURE;
714
axutil_qname_free(element_qname, env);
715
element_qname = NULL;
721
axis2_bool_t AXIS2_CALL
722
adb_ncStartNetworkResponseType_is_particle()
731
adb_ncStartNetworkResponseType_declare_parent_namespaces(
732
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
733
const axutil_env_t *env, axiom_element_t *parent_element,
734
axutil_hash_t *namespaces, int *next_ns_index)
737
/* Here this is an empty function, Nothing to declare */
743
axiom_node_t* AXIS2_CALL
744
adb_ncStartNetworkResponseType_serialize(
745
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
746
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)
750
axis2_char_t *string_to_stream;
753
axiom_node_t *current_node = NULL;
758
axiom_namespace_t *ns1 = NULL;
760
axis2_char_t *qname_uri = NULL;
761
axis2_char_t *qname_prefix = NULL;
762
axis2_char_t *p_prefix = NULL;
763
axis2_bool_t ns_already_defined;
765
axis2_char_t *text_value_1;
766
axis2_char_t *text_value_1_temp;
768
axis2_char_t *text_value_2;
769
axis2_char_t *text_value_2_temp;
771
axis2_char_t text_value_3[64];
773
axis2_char_t *text_value_4;
774
axis2_char_t *text_value_4_temp;
776
axis2_char_t text_value_5[64];
778
axis2_char_t *text_value_6;
779
axis2_char_t *text_value_6_temp;
781
axis2_char_t *start_input_str = NULL;
782
axis2_char_t *end_input_str = NULL;
783
unsigned int start_input_str_len = 0;
784
unsigned int end_input_str_len = 0;
787
axiom_data_source_t *data_source = NULL;
788
axutil_stream_t *stream = NULL;
792
AXIS2_ENV_CHECK(env, NULL);
793
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, NULL);
796
current_node = parent;
797
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
800
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
804
if(!parent_tag_closed)
807
string_to_stream = ">";
808
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
813
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
815
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
816
sprintf(p_prefix, "n%d", (*next_ns_index)++);
817
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
819
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
820
"http://eucalyptus.ucsb.edu/",
825
if (!_ncStartNetworkResponseType->is_valid_correlationId)
828
/* no need to complain for minoccurs=0 element */
834
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
835
(4 + axutil_strlen(p_prefix) +
836
axutil_strlen("correlationId")));
838
/* axutil_strlen("<:>") + 1 = 4 */
839
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
840
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
841
/* axutil_strlen("</:>") + 1 = 5 */
849
* parsing correlationId element
854
sprintf(start_input_str, "<%s%scorrelationId>",
855
p_prefix?p_prefix:"",
856
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
858
start_input_str_len = axutil_strlen(start_input_str);
859
sprintf(end_input_str, "</%s%scorrelationId>",
860
p_prefix?p_prefix:"",
861
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
862
end_input_str_len = axutil_strlen(end_input_str);
864
text_value_1 = _ncStartNetworkResponseType->property_correlationId;
866
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
869
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
870
if (text_value_1_temp)
872
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
873
AXIS2_FREE(env->allocator, text_value_1_temp);
877
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
880
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
883
AXIS2_FREE(env->allocator,start_input_str);
884
AXIS2_FREE(env->allocator,end_input_str);
888
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
890
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
891
sprintf(p_prefix, "n%d", (*next_ns_index)++);
892
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
894
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
895
"http://eucalyptus.ucsb.edu/",
900
if (!_ncStartNetworkResponseType->is_valid_userId)
903
/* no need to complain for minoccurs=0 element */
909
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
910
(4 + axutil_strlen(p_prefix) +
911
axutil_strlen("userId")));
913
/* axutil_strlen("<:>") + 1 = 4 */
914
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
915
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
916
/* axutil_strlen("</:>") + 1 = 5 */
924
* parsing userId element
929
sprintf(start_input_str, "<%s%suserId>",
930
p_prefix?p_prefix:"",
931
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
933
start_input_str_len = axutil_strlen(start_input_str);
934
sprintf(end_input_str, "</%s%suserId>",
935
p_prefix?p_prefix:"",
936
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
937
end_input_str_len = axutil_strlen(end_input_str);
939
text_value_2 = _ncStartNetworkResponseType->property_userId;
941
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
944
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
945
if (text_value_2_temp)
947
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
948
AXIS2_FREE(env->allocator, text_value_2_temp);
952
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
955
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
958
AXIS2_FREE(env->allocator,start_input_str);
959
AXIS2_FREE(env->allocator,end_input_str);
963
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
965
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
966
sprintf(p_prefix, "n%d", (*next_ns_index)++);
967
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
969
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
970
"http://eucalyptus.ucsb.edu/",
975
if (!_ncStartNetworkResponseType->is_valid_return)
978
/* no need to complain for minoccurs=0 element */
984
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
985
(4 + axutil_strlen(p_prefix) +
986
axutil_strlen("return")));
988
/* axutil_strlen("<:>") + 1 = 4 */
989
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
990
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
991
/* axutil_strlen("</:>") + 1 = 5 */
999
* parsing return element
1004
sprintf(start_input_str, "<%s%sreturn>",
1005
p_prefix?p_prefix:"",
1006
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1008
start_input_str_len = axutil_strlen(start_input_str);
1009
sprintf(end_input_str, "</%s%sreturn>",
1010
p_prefix?p_prefix:"",
1011
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1012
end_input_str_len = axutil_strlen(end_input_str);
1014
strcpy(text_value_3, (_ncStartNetworkResponseType->property_return)?"true":"false");
1016
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1018
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1020
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1023
AXIS2_FREE(env->allocator,start_input_str);
1024
AXIS2_FREE(env->allocator,end_input_str);
1028
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1030
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1031
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1032
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1034
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1035
"http://eucalyptus.ucsb.edu/",
1040
if (!_ncStartNetworkResponseType->is_valid_nodeName)
1043
/* no need to complain for minoccurs=0 element */
1049
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1050
(4 + axutil_strlen(p_prefix) +
1051
axutil_strlen("nodeName")));
1053
/* axutil_strlen("<:>") + 1 = 4 */
1054
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1055
(5 + axutil_strlen(p_prefix) + axutil_strlen("nodeName")));
1056
/* axutil_strlen("</:>") + 1 = 5 */
1064
* parsing nodeName element
1069
sprintf(start_input_str, "<%s%snodeName>",
1070
p_prefix?p_prefix:"",
1071
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1073
start_input_str_len = axutil_strlen(start_input_str);
1074
sprintf(end_input_str, "</%s%snodeName>",
1075
p_prefix?p_prefix:"",
1076
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1077
end_input_str_len = axutil_strlen(end_input_str);
1079
text_value_4 = _ncStartNetworkResponseType->property_nodeName;
1081
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1084
text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
1085
if (text_value_4_temp)
1087
axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
1088
AXIS2_FREE(env->allocator, text_value_4_temp);
1092
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1095
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1098
AXIS2_FREE(env->allocator,start_input_str);
1099
AXIS2_FREE(env->allocator,end_input_str);
1103
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1105
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1106
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1107
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1109
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1110
"http://eucalyptus.ucsb.edu/",
1115
if (!_ncStartNetworkResponseType->is_valid_statusMessage)
1118
/* no need to complain for minoccurs=0 element */
1124
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1125
(4 + axutil_strlen(p_prefix) +
1126
axutil_strlen("statusMessage")));
1128
/* axutil_strlen("<:>") + 1 = 4 */
1129
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1130
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1131
/* axutil_strlen("</:>") + 1 = 5 */
1139
* parsing statusMessage element
1144
sprintf(start_input_str, "<%s%sstatusMessage>",
1145
p_prefix?p_prefix:"",
1146
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1148
start_input_str_len = axutil_strlen(start_input_str);
1149
sprintf(end_input_str, "</%s%sstatusMessage>",
1150
p_prefix?p_prefix:"",
1151
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1152
end_input_str_len = axutil_strlen(end_input_str);
1154
sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncStartNetworkResponseType->property_statusMessage);
1156
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1158
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1160
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1163
AXIS2_FREE(env->allocator,start_input_str);
1164
AXIS2_FREE(env->allocator,end_input_str);
1168
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1170
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1171
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1172
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1174
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1175
"http://eucalyptus.ucsb.edu/",
1180
if (!_ncStartNetworkResponseType->is_valid_networkStatus)
1183
/* no need to complain for minoccurs=0 element */
1189
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1190
(4 + axutil_strlen(p_prefix) +
1191
axutil_strlen("networkStatus")));
1193
/* axutil_strlen("<:>") + 1 = 4 */
1194
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1195
(5 + axutil_strlen(p_prefix) + axutil_strlen("networkStatus")));
1196
/* axutil_strlen("</:>") + 1 = 5 */
1204
* parsing networkStatus element
1209
sprintf(start_input_str, "<%s%snetworkStatus>",
1210
p_prefix?p_prefix:"",
1211
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1213
start_input_str_len = axutil_strlen(start_input_str);
1214
sprintf(end_input_str, "</%s%snetworkStatus>",
1215
p_prefix?p_prefix:"",
1216
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1217
end_input_str_len = axutil_strlen(end_input_str);
1219
text_value_6 = _ncStartNetworkResponseType->property_networkStatus;
1221
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1224
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1225
if (text_value_6_temp)
1227
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1228
AXIS2_FREE(env->allocator, text_value_6_temp);
1232
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1235
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1238
AXIS2_FREE(env->allocator,start_input_str);
1239
AXIS2_FREE(env->allocator,end_input_str);
1251
* getter for correlationId.
1253
axis2_char_t* AXIS2_CALL
1254
adb_ncStartNetworkResponseType_get_correlationId(
1255
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1256
const axutil_env_t *env)
1259
AXIS2_ENV_CHECK(env, NULL);
1260
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, NULL);
1263
return _ncStartNetworkResponseType->property_correlationId;
1267
* setter for correlationId
1269
axis2_status_t AXIS2_CALL
1270
adb_ncStartNetworkResponseType_set_correlationId(
1271
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1272
const axutil_env_t *env,
1273
const axis2_char_t* arg_correlationId)
1277
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1278
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1280
if(_ncStartNetworkResponseType->is_valid_correlationId &&
1281
arg_correlationId == _ncStartNetworkResponseType->property_correlationId)
1284
return AXIS2_SUCCESS;
1287
adb_ncStartNetworkResponseType_reset_correlationId(_ncStartNetworkResponseType, env);
1290
if(NULL == arg_correlationId)
1292
/* We are already done */
1293
return AXIS2_SUCCESS;
1295
_ncStartNetworkResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1296
if(NULL == _ncStartNetworkResponseType->property_correlationId)
1298
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1299
return AXIS2_FAILURE;
1301
_ncStartNetworkResponseType->is_valid_correlationId = AXIS2_TRUE;
1303
return AXIS2_SUCCESS;
1309
* resetter for correlationId
1311
axis2_status_t AXIS2_CALL
1312
adb_ncStartNetworkResponseType_reset_correlationId(
1313
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1314
const axutil_env_t *env)
1318
void *element = NULL;
1320
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1321
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1327
if(_ncStartNetworkResponseType->property_correlationId != NULL)
1331
AXIS2_FREE(env-> allocator, _ncStartNetworkResponseType->property_correlationId);
1332
_ncStartNetworkResponseType->property_correlationId = NULL;
1337
_ncStartNetworkResponseType->is_valid_correlationId = AXIS2_FALSE;
1338
return AXIS2_SUCCESS;
1342
* Check whether correlationId is nill
1344
axis2_bool_t AXIS2_CALL
1345
adb_ncStartNetworkResponseType_is_correlationId_nil(
1346
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1347
const axutil_env_t *env)
1349
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1350
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_TRUE);
1352
return !_ncStartNetworkResponseType->is_valid_correlationId;
1356
* Set correlationId to nill (currently the same as reset)
1358
axis2_status_t AXIS2_CALL
1359
adb_ncStartNetworkResponseType_set_correlationId_nil(
1360
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1361
const axutil_env_t *env)
1363
return adb_ncStartNetworkResponseType_reset_correlationId(_ncStartNetworkResponseType, env);
1369
* getter for userId.
1371
axis2_char_t* AXIS2_CALL
1372
adb_ncStartNetworkResponseType_get_userId(
1373
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1374
const axutil_env_t *env)
1377
AXIS2_ENV_CHECK(env, NULL);
1378
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, NULL);
1381
return _ncStartNetworkResponseType->property_userId;
1387
axis2_status_t AXIS2_CALL
1388
adb_ncStartNetworkResponseType_set_userId(
1389
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1390
const axutil_env_t *env,
1391
const axis2_char_t* arg_userId)
1395
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1396
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1398
if(_ncStartNetworkResponseType->is_valid_userId &&
1399
arg_userId == _ncStartNetworkResponseType->property_userId)
1402
return AXIS2_SUCCESS;
1405
adb_ncStartNetworkResponseType_reset_userId(_ncStartNetworkResponseType, env);
1408
if(NULL == arg_userId)
1410
/* We are already done */
1411
return AXIS2_SUCCESS;
1413
_ncStartNetworkResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1414
if(NULL == _ncStartNetworkResponseType->property_userId)
1416
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1417
return AXIS2_FAILURE;
1419
_ncStartNetworkResponseType->is_valid_userId = AXIS2_TRUE;
1421
return AXIS2_SUCCESS;
1427
* resetter for userId
1429
axis2_status_t AXIS2_CALL
1430
adb_ncStartNetworkResponseType_reset_userId(
1431
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1432
const axutil_env_t *env)
1436
void *element = NULL;
1438
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1439
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1445
if(_ncStartNetworkResponseType->property_userId != NULL)
1449
AXIS2_FREE(env-> allocator, _ncStartNetworkResponseType->property_userId);
1450
_ncStartNetworkResponseType->property_userId = NULL;
1455
_ncStartNetworkResponseType->is_valid_userId = AXIS2_FALSE;
1456
return AXIS2_SUCCESS;
1460
* Check whether userId is nill
1462
axis2_bool_t AXIS2_CALL
1463
adb_ncStartNetworkResponseType_is_userId_nil(
1464
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1465
const axutil_env_t *env)
1467
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1468
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_TRUE);
1470
return !_ncStartNetworkResponseType->is_valid_userId;
1474
* Set userId to nill (currently the same as reset)
1476
axis2_status_t AXIS2_CALL
1477
adb_ncStartNetworkResponseType_set_userId_nil(
1478
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1479
const axutil_env_t *env)
1481
return adb_ncStartNetworkResponseType_reset_userId(_ncStartNetworkResponseType, env);
1487
* getter for return.
1489
axis2_bool_t AXIS2_CALL
1490
adb_ncStartNetworkResponseType_get_return(
1491
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1492
const axutil_env_t *env)
1495
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1496
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, (axis2_bool_t)0);
1499
return _ncStartNetworkResponseType->property_return;
1505
axis2_status_t AXIS2_CALL
1506
adb_ncStartNetworkResponseType_set_return(
1507
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1508
const axutil_env_t *env,
1509
axis2_bool_t arg_return)
1513
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1514
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1516
if(_ncStartNetworkResponseType->is_valid_return &&
1517
arg_return == _ncStartNetworkResponseType->property_return)
1520
return AXIS2_SUCCESS;
1523
adb_ncStartNetworkResponseType_reset_return(_ncStartNetworkResponseType, env);
1525
_ncStartNetworkResponseType->property_return = arg_return;
1526
_ncStartNetworkResponseType->is_valid_return = AXIS2_TRUE;
1528
return AXIS2_SUCCESS;
1534
* resetter for return
1536
axis2_status_t AXIS2_CALL
1537
adb_ncStartNetworkResponseType_reset_return(
1538
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1539
const axutil_env_t *env)
1543
void *element = NULL;
1545
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1546
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1549
_ncStartNetworkResponseType->is_valid_return = AXIS2_FALSE;
1550
return AXIS2_SUCCESS;
1554
* Check whether return is nill
1556
axis2_bool_t AXIS2_CALL
1557
adb_ncStartNetworkResponseType_is_return_nil(
1558
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1559
const axutil_env_t *env)
1561
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1562
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_TRUE);
1564
return !_ncStartNetworkResponseType->is_valid_return;
1568
* Set return to nill (currently the same as reset)
1570
axis2_status_t AXIS2_CALL
1571
adb_ncStartNetworkResponseType_set_return_nil(
1572
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1573
const axutil_env_t *env)
1575
return adb_ncStartNetworkResponseType_reset_return(_ncStartNetworkResponseType, env);
1581
* getter for nodeName.
1583
axis2_char_t* AXIS2_CALL
1584
adb_ncStartNetworkResponseType_get_nodeName(
1585
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1586
const axutil_env_t *env)
1589
AXIS2_ENV_CHECK(env, NULL);
1590
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, NULL);
1593
return _ncStartNetworkResponseType->property_nodeName;
1597
* setter for nodeName
1599
axis2_status_t AXIS2_CALL
1600
adb_ncStartNetworkResponseType_set_nodeName(
1601
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1602
const axutil_env_t *env,
1603
const axis2_char_t* arg_nodeName)
1607
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1608
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1610
if(_ncStartNetworkResponseType->is_valid_nodeName &&
1611
arg_nodeName == _ncStartNetworkResponseType->property_nodeName)
1614
return AXIS2_SUCCESS;
1617
adb_ncStartNetworkResponseType_reset_nodeName(_ncStartNetworkResponseType, env);
1620
if(NULL == arg_nodeName)
1622
/* We are already done */
1623
return AXIS2_SUCCESS;
1625
_ncStartNetworkResponseType->property_nodeName = (axis2_char_t *)axutil_strdup(env, arg_nodeName);
1626
if(NULL == _ncStartNetworkResponseType->property_nodeName)
1628
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeName");
1629
return AXIS2_FAILURE;
1631
_ncStartNetworkResponseType->is_valid_nodeName = AXIS2_TRUE;
1633
return AXIS2_SUCCESS;
1639
* resetter for nodeName
1641
axis2_status_t AXIS2_CALL
1642
adb_ncStartNetworkResponseType_reset_nodeName(
1643
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1644
const axutil_env_t *env)
1648
void *element = NULL;
1650
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1651
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1657
if(_ncStartNetworkResponseType->property_nodeName != NULL)
1661
AXIS2_FREE(env-> allocator, _ncStartNetworkResponseType->property_nodeName);
1662
_ncStartNetworkResponseType->property_nodeName = NULL;
1667
_ncStartNetworkResponseType->is_valid_nodeName = AXIS2_FALSE;
1668
return AXIS2_SUCCESS;
1672
* Check whether nodeName is nill
1674
axis2_bool_t AXIS2_CALL
1675
adb_ncStartNetworkResponseType_is_nodeName_nil(
1676
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1677
const axutil_env_t *env)
1679
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1680
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_TRUE);
1682
return !_ncStartNetworkResponseType->is_valid_nodeName;
1686
* Set nodeName to nill (currently the same as reset)
1688
axis2_status_t AXIS2_CALL
1689
adb_ncStartNetworkResponseType_set_nodeName_nil(
1690
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1691
const axutil_env_t *env)
1693
return adb_ncStartNetworkResponseType_reset_nodeName(_ncStartNetworkResponseType, env);
1699
* getter for statusMessage.
1702
adb_ncStartNetworkResponseType_get_statusMessage(
1703
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1704
const axutil_env_t *env)
1707
AXIS2_ENV_CHECK(env, (int)0);
1708
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, (int)0);
1711
return _ncStartNetworkResponseType->property_statusMessage;
1715
* setter for statusMessage
1717
axis2_status_t AXIS2_CALL
1718
adb_ncStartNetworkResponseType_set_statusMessage(
1719
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1720
const axutil_env_t *env,
1721
const int arg_statusMessage)
1725
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1726
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1728
if(_ncStartNetworkResponseType->is_valid_statusMessage &&
1729
arg_statusMessage == _ncStartNetworkResponseType->property_statusMessage)
1732
return AXIS2_SUCCESS;
1735
adb_ncStartNetworkResponseType_reset_statusMessage(_ncStartNetworkResponseType, env);
1737
_ncStartNetworkResponseType->property_statusMessage = arg_statusMessage;
1738
_ncStartNetworkResponseType->is_valid_statusMessage = AXIS2_TRUE;
1740
return AXIS2_SUCCESS;
1746
* resetter for statusMessage
1748
axis2_status_t AXIS2_CALL
1749
adb_ncStartNetworkResponseType_reset_statusMessage(
1750
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1751
const axutil_env_t *env)
1755
void *element = NULL;
1757
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1758
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1761
_ncStartNetworkResponseType->is_valid_statusMessage = AXIS2_FALSE;
1762
return AXIS2_SUCCESS;
1766
* Check whether statusMessage is nill
1768
axis2_bool_t AXIS2_CALL
1769
adb_ncStartNetworkResponseType_is_statusMessage_nil(
1770
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1771
const axutil_env_t *env)
1773
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1774
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_TRUE);
1776
return !_ncStartNetworkResponseType->is_valid_statusMessage;
1780
* Set statusMessage to nill (currently the same as reset)
1782
axis2_status_t AXIS2_CALL
1783
adb_ncStartNetworkResponseType_set_statusMessage_nil(
1784
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1785
const axutil_env_t *env)
1787
return adb_ncStartNetworkResponseType_reset_statusMessage(_ncStartNetworkResponseType, env);
1793
* getter for networkStatus.
1795
axis2_char_t* AXIS2_CALL
1796
adb_ncStartNetworkResponseType_get_networkStatus(
1797
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1798
const axutil_env_t *env)
1801
AXIS2_ENV_CHECK(env, NULL);
1802
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, NULL);
1805
return _ncStartNetworkResponseType->property_networkStatus;
1809
* setter for networkStatus
1811
axis2_status_t AXIS2_CALL
1812
adb_ncStartNetworkResponseType_set_networkStatus(
1813
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1814
const axutil_env_t *env,
1815
const axis2_char_t* arg_networkStatus)
1819
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1820
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1822
if(_ncStartNetworkResponseType->is_valid_networkStatus &&
1823
arg_networkStatus == _ncStartNetworkResponseType->property_networkStatus)
1826
return AXIS2_SUCCESS;
1829
adb_ncStartNetworkResponseType_reset_networkStatus(_ncStartNetworkResponseType, env);
1832
if(NULL == arg_networkStatus)
1834
/* We are already done */
1835
return AXIS2_SUCCESS;
1837
_ncStartNetworkResponseType->property_networkStatus = (axis2_char_t *)axutil_strdup(env, arg_networkStatus);
1838
if(NULL == _ncStartNetworkResponseType->property_networkStatus)
1840
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for networkStatus");
1841
return AXIS2_FAILURE;
1843
_ncStartNetworkResponseType->is_valid_networkStatus = AXIS2_TRUE;
1845
return AXIS2_SUCCESS;
1851
* resetter for networkStatus
1853
axis2_status_t AXIS2_CALL
1854
adb_ncStartNetworkResponseType_reset_networkStatus(
1855
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1856
const axutil_env_t *env)
1860
void *element = NULL;
1862
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1863
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_FAILURE);
1869
if(_ncStartNetworkResponseType->property_networkStatus != NULL)
1873
AXIS2_FREE(env-> allocator, _ncStartNetworkResponseType->property_networkStatus);
1874
_ncStartNetworkResponseType->property_networkStatus = NULL;
1879
_ncStartNetworkResponseType->is_valid_networkStatus = AXIS2_FALSE;
1880
return AXIS2_SUCCESS;
1884
* Check whether networkStatus is nill
1886
axis2_bool_t AXIS2_CALL
1887
adb_ncStartNetworkResponseType_is_networkStatus_nil(
1888
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1889
const axutil_env_t *env)
1891
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1892
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponseType, AXIS2_TRUE);
1894
return !_ncStartNetworkResponseType->is_valid_networkStatus;
1898
* Set networkStatus to nill (currently the same as reset)
1900
axis2_status_t AXIS2_CALL
1901
adb_ncStartNetworkResponseType_set_networkStatus_nil(
1902
adb_ncStartNetworkResponseType_t* _ncStartNetworkResponseType,
1903
const axutil_env_t *env)
1905
return adb_ncStartNetworkResponseType_reset_networkStatus(_ncStartNetworkResponseType, env);
added
removed
node/generated/adb_ncStartNetworkResponseType.c
