4
* adb_ncStartNetworkType.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_ncStartNetworkType.h"
13
* This type was generated from the piece of schema that had
14
* name = ncStartNetworkType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_ncStartNetworkType
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
int property_statusMessage;
44
axis2_bool_t is_valid_statusMessage;
47
axutil_array_list_t* property_remoteHosts;
50
axis2_bool_t is_valid_remoteHosts;
53
int property_remoteHostPort;
56
axis2_bool_t is_valid_remoteHostPort;
62
axis2_bool_t is_valid_vlan;
69
/************************* Private Function prototypes ********************************/
72
axis2_status_t AXIS2_CALL
73
adb_ncStartNetworkType_set_correlationId_nil(
74
adb_ncStartNetworkType_t* _ncStartNetworkType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_ncStartNetworkType_set_userId_nil(
80
adb_ncStartNetworkType_t* _ncStartNetworkType,
81
const axutil_env_t *env);
84
axis2_status_t AXIS2_CALL
85
adb_ncStartNetworkType_set_return_nil(
86
adb_ncStartNetworkType_t* _ncStartNetworkType,
87
const axutil_env_t *env);
89
axis2_status_t AXIS2_CALL
90
adb_ncStartNetworkType_set_remoteHosts_nil_at(
91
adb_ncStartNetworkType_t* _ncStartNetworkType,
92
const axutil_env_t *env, int i);
95
axis2_status_t AXIS2_CALL
96
adb_ncStartNetworkType_set_remoteHosts_nil(
97
adb_ncStartNetworkType_t* _ncStartNetworkType,
98
const axutil_env_t *env);
101
axis2_status_t AXIS2_CALL
102
adb_ncStartNetworkType_set_remoteHostPort_nil(
103
adb_ncStartNetworkType_t* _ncStartNetworkType,
104
const axutil_env_t *env);
107
axis2_status_t AXIS2_CALL
108
adb_ncStartNetworkType_set_vlan_nil(
109
adb_ncStartNetworkType_t* _ncStartNetworkType,
110
const axutil_env_t *env);
114
/************************* Function Implmentations ********************************/
115
adb_ncStartNetworkType_t* AXIS2_CALL
116
adb_ncStartNetworkType_create(
117
const axutil_env_t *env)
119
adb_ncStartNetworkType_t *_ncStartNetworkType = NULL;
121
AXIS2_ENV_CHECK(env, NULL);
123
_ncStartNetworkType = (adb_ncStartNetworkType_t *) AXIS2_MALLOC(env->
124
allocator, sizeof(adb_ncStartNetworkType_t));
126
if(NULL == _ncStartNetworkType)
128
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
132
memset(_ncStartNetworkType, 0, sizeof(adb_ncStartNetworkType_t));
134
_ncStartNetworkType->property_correlationId = NULL;
135
_ncStartNetworkType->is_valid_correlationId = AXIS2_FALSE;
136
_ncStartNetworkType->property_userId = NULL;
137
_ncStartNetworkType->is_valid_userId = AXIS2_FALSE;
138
_ncStartNetworkType->is_valid_return = AXIS2_FALSE;
139
_ncStartNetworkType->is_valid_statusMessage = AXIS2_FALSE;
140
_ncStartNetworkType->property_remoteHosts = NULL;
141
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_FALSE;
142
_ncStartNetworkType->is_valid_remoteHostPort = AXIS2_FALSE;
143
_ncStartNetworkType->is_valid_vlan = AXIS2_FALSE;
146
return _ncStartNetworkType;
149
axis2_status_t AXIS2_CALL
150
adb_ncStartNetworkType_free (
151
adb_ncStartNetworkType_t* _ncStartNetworkType,
152
const axutil_env_t *env)
157
void *element = NULL;
160
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
161
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
163
adb_ncStartNetworkType_reset_correlationId(_ncStartNetworkType, env);
164
adb_ncStartNetworkType_reset_userId(_ncStartNetworkType, env);
165
adb_ncStartNetworkType_reset_return(_ncStartNetworkType, env);
166
adb_ncStartNetworkType_reset_statusMessage(_ncStartNetworkType, env);
167
adb_ncStartNetworkType_reset_remoteHosts(_ncStartNetworkType, env);
168
adb_ncStartNetworkType_reset_remoteHostPort(_ncStartNetworkType, env);
169
adb_ncStartNetworkType_reset_vlan(_ncStartNetworkType, env);
172
if(_ncStartNetworkType)
174
AXIS2_FREE(env->allocator, _ncStartNetworkType);
175
_ncStartNetworkType = NULL;
177
return AXIS2_SUCCESS;
183
axis2_status_t AXIS2_CALL
184
adb_ncStartNetworkType_deserialize(
185
adb_ncStartNetworkType_t* _ncStartNetworkType,
186
const axutil_env_t *env,
187
axiom_node_t **dp_parent,
188
axis2_bool_t *dp_is_early_node_valid,
189
axis2_bool_t dont_care_minoccurs)
191
axiom_node_t *parent = *dp_parent;
193
axis2_status_t status = AXIS2_SUCCESS;
195
void *element = NULL;
197
axis2_char_t* text_value = NULL;
198
axutil_qname_t *qname = NULL;
201
axutil_array_list_t *arr_list = NULL;
203
int sequence_broken = 0;
204
axiom_node_t *tmp_node = NULL;
206
axutil_qname_t *element_qname = NULL;
208
axiom_node_t *first_node = NULL;
209
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
210
axiom_node_t *current_node = NULL;
211
axiom_element_t *current_element = NULL;
213
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
214
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
218
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
220
parent = axiom_node_get_next_sibling(parent, env);
224
/* This should be checked before everything */
225
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
226
"Failed in building adb object for ncStartNetworkType : "
227
"NULL elemenet can not be passed to deserialize");
228
return AXIS2_FAILURE;
232
first_node = axiom_node_get_first_child(parent, env);
238
* building correlationId element
243
current_node = first_node;
244
is_early_node_valid = AXIS2_FALSE;
247
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
249
current_node = axiom_node_get_next_sibling(current_node, env);
251
if(current_node != NULL)
253
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
254
qname = axiom_element_get_qname(current_element, env, current_node);
257
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
261
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
263
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
265
is_early_node_valid = AXIS2_TRUE;
269
text_value = axiom_element_get_text(current_element, env, current_node);
270
if(text_value != NULL)
272
status = adb_ncStartNetworkType_set_correlationId(_ncStartNetworkType, env,
279
* axis2_qname_t *qname = NULL;
280
* axiom_attribute_t *the_attri = NULL;
282
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
283
* the_attri = axiom_element_get_attribute(current_element, env, qname);
285
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
287
axiom_attribute_t *the_attri = NULL;
288
axis2_char_t *attrib_text = NULL;
289
axutil_hash_t *attribute_hash = NULL;
291
attribute_hash = axiom_element_get_all_attributes(current_element, env);
296
axutil_hash_index_t *hi;
300
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
302
axutil_hash_this(hi, &key, NULL, &val);
304
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
306
the_attri = (axiom_attribute_t*)val;
314
attrib_text = axiom_attribute_get_value(the_attri, env);
318
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
319
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
322
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
324
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
325
status = AXIS2_FAILURE;
329
/* after all, we found this is a empty string */
330
status = adb_ncStartNetworkType_set_correlationId(_ncStartNetworkType, env,
335
if(AXIS2_FAILURE == status)
337
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
340
axutil_qname_free(element_qname, env);
342
return AXIS2_FAILURE;
348
axutil_qname_free(element_qname, env);
349
element_qname = NULL;
355
* building userId element
361
* because elements are ordered this works fine
365
if(current_node != NULL && is_early_node_valid)
367
current_node = axiom_node_get_next_sibling(current_node, env);
370
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
372
current_node = axiom_node_get_next_sibling(current_node, env);
374
if(current_node != NULL)
376
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
377
qname = axiom_element_get_qname(current_element, env, current_node);
381
is_early_node_valid = AXIS2_FALSE;
383
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
387
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
389
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
391
is_early_node_valid = AXIS2_TRUE;
395
text_value = axiom_element_get_text(current_element, env, current_node);
396
if(text_value != NULL)
398
status = adb_ncStartNetworkType_set_userId(_ncStartNetworkType, env,
405
* axis2_qname_t *qname = NULL;
406
* axiom_attribute_t *the_attri = NULL;
408
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
409
* the_attri = axiom_element_get_attribute(current_element, env, qname);
411
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
413
axiom_attribute_t *the_attri = NULL;
414
axis2_char_t *attrib_text = NULL;
415
axutil_hash_t *attribute_hash = NULL;
417
attribute_hash = axiom_element_get_all_attributes(current_element, env);
422
axutil_hash_index_t *hi;
426
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
428
axutil_hash_this(hi, &key, NULL, &val);
430
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
432
the_attri = (axiom_attribute_t*)val;
440
attrib_text = axiom_attribute_get_value(the_attri, env);
444
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
445
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
448
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
450
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
451
status = AXIS2_FAILURE;
455
/* after all, we found this is a empty string */
456
status = adb_ncStartNetworkType_set_userId(_ncStartNetworkType, env,
461
if(AXIS2_FAILURE == status)
463
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
466
axutil_qname_free(element_qname, env);
468
return AXIS2_FAILURE;
474
axutil_qname_free(element_qname, env);
475
element_qname = NULL;
481
* building return element
487
* because elements are ordered this works fine
491
if(current_node != NULL && is_early_node_valid)
493
current_node = axiom_node_get_next_sibling(current_node, env);
496
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
498
current_node = axiom_node_get_next_sibling(current_node, env);
500
if(current_node != NULL)
502
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
503
qname = axiom_element_get_qname(current_element, env, current_node);
507
is_early_node_valid = AXIS2_FALSE;
509
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
513
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
515
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
517
is_early_node_valid = AXIS2_TRUE;
521
text_value = axiom_element_get_text(current_element, env, current_node);
522
if(text_value != NULL)
524
if (!axutil_strcasecmp(text_value , "true"))
526
status = adb_ncStartNetworkType_set_return(_ncStartNetworkType, env,
531
status = adb_ncStartNetworkType_set_return(_ncStartNetworkType, env,
538
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
539
status = AXIS2_FAILURE;
542
if(AXIS2_FAILURE == status)
544
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
547
axutil_qname_free(element_qname, env);
549
return AXIS2_FAILURE;
555
axutil_qname_free(element_qname, env);
556
element_qname = NULL;
562
* building statusMessage element
568
* because elements are ordered this works fine
572
if(current_node != NULL && is_early_node_valid)
574
current_node = axiom_node_get_next_sibling(current_node, env);
577
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
579
current_node = axiom_node_get_next_sibling(current_node, env);
581
if(current_node != NULL)
583
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
584
qname = axiom_element_get_qname(current_element, env, current_node);
588
is_early_node_valid = AXIS2_FALSE;
590
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
594
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
596
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
598
is_early_node_valid = AXIS2_TRUE;
602
text_value = axiom_element_get_text(current_element, env, current_node);
603
if(text_value != NULL)
605
status = adb_ncStartNetworkType_set_statusMessage(_ncStartNetworkType, env,
609
if(AXIS2_FAILURE == status)
611
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
614
axutil_qname_free(element_qname, env);
616
return AXIS2_FAILURE;
622
axutil_qname_free(element_qname, env);
623
element_qname = NULL;
627
* building remoteHosts array
629
arr_list = axutil_array_list_create(env, 10);
634
* building remoteHosts element
639
element_qname = axutil_qname_create(env, "remoteHosts", "http://eucalyptus.ucsb.edu/", NULL);
642
for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
645
if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
647
current_node =axiom_node_get_next_sibling(current_node, env);
648
is_early_node_valid = AXIS2_FALSE;
652
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
653
qname = axiom_element_get_qname(current_element, env, current_node);
655
if (axutil_qname_equals(element_qname, env, qname))
658
is_early_node_valid = AXIS2_TRUE;
661
text_value = axiom_element_get_text(current_element, env, current_node);
662
if(text_value != NULL)
664
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
670
* axis2_qname_t *qname = NULL;
671
* axiom_attribute_t *the_attri = NULL;
673
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
674
* the_attri = axiom_element_get_attribute(current_element, env, qname);
677
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
679
axiom_attribute_t *the_attri = NULL;
680
axis2_char_t *attrib_text = NULL;
681
axutil_hash_t *attribute_hash = NULL;
683
attribute_hash = axiom_element_get_all_attributes(current_element, env);
688
axutil_hash_index_t *hi;
692
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
694
axutil_hash_this(hi, &key, NULL, &val);
696
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
698
the_attri = (axiom_attribute_t*)val;
706
attrib_text = axiom_attribute_get_value(the_attri, env);
710
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
711
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
714
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
716
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element remoteHosts");
717
status = AXIS2_FAILURE;
721
/* after all, we found this is a empty string */
722
axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
726
if(AXIS2_FAILURE == status)
728
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for remoteHosts ");
731
axutil_qname_free(element_qname, env);
735
axutil_array_list_free(arr_list, env);
737
return AXIS2_FAILURE;
741
current_node = axiom_node_get_next_sibling(current_node, env);
745
is_early_node_valid = AXIS2_FALSE;
754
/* found element out of order */
755
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "remoteHosts (@minOccurs = '0') only have %d elements", i);
758
axutil_qname_free(element_qname, env);
762
axutil_array_list_free(arr_list, env);
764
return AXIS2_FAILURE;
768
if(0 == axutil_array_list_size(arr_list,env))
770
axutil_array_list_free(arr_list, env);
774
status = adb_ncStartNetworkType_set_remoteHosts(_ncStartNetworkType, env,
781
axutil_qname_free(element_qname, env);
782
element_qname = NULL;
788
* building remoteHostPort element
794
* because elements are ordered this works fine
798
if(current_node != NULL && is_early_node_valid)
800
current_node = axiom_node_get_next_sibling(current_node, env);
803
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
805
current_node = axiom_node_get_next_sibling(current_node, env);
807
if(current_node != NULL)
809
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
810
qname = axiom_element_get_qname(current_element, env, current_node);
814
is_early_node_valid = AXIS2_FALSE;
816
element_qname = axutil_qname_create(env, "remoteHostPort", "http://eucalyptus.ucsb.edu/", NULL);
820
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
822
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
824
is_early_node_valid = AXIS2_TRUE;
828
text_value = axiom_element_get_text(current_element, env, current_node);
829
if(text_value != NULL)
831
status = adb_ncStartNetworkType_set_remoteHostPort(_ncStartNetworkType, env,
837
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element remoteHostPort");
838
status = AXIS2_FAILURE;
841
if(AXIS2_FAILURE == status)
843
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for remoteHostPort ");
846
axutil_qname_free(element_qname, env);
848
return AXIS2_FAILURE;
854
axutil_qname_free(element_qname, env);
855
element_qname = NULL;
861
* building vlan element
867
* because elements are ordered this works fine
871
if(current_node != NULL && is_early_node_valid)
873
current_node = axiom_node_get_next_sibling(current_node, env);
876
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
878
current_node = axiom_node_get_next_sibling(current_node, env);
880
if(current_node != NULL)
882
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
883
qname = axiom_element_get_qname(current_element, env, current_node);
887
is_early_node_valid = AXIS2_FALSE;
889
element_qname = axutil_qname_create(env, "vlan", "http://eucalyptus.ucsb.edu/", NULL);
893
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
895
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
897
is_early_node_valid = AXIS2_TRUE;
901
text_value = axiom_element_get_text(current_element, env, current_node);
902
if(text_value != NULL)
904
status = adb_ncStartNetworkType_set_vlan(_ncStartNetworkType, env,
910
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element vlan");
911
status = AXIS2_FAILURE;
914
if(AXIS2_FAILURE == status)
916
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for vlan ");
919
axutil_qname_free(element_qname, env);
921
return AXIS2_FAILURE;
927
axutil_qname_free(element_qname, env);
928
element_qname = NULL;
934
axis2_bool_t AXIS2_CALL
935
adb_ncStartNetworkType_is_particle()
944
adb_ncStartNetworkType_declare_parent_namespaces(
945
adb_ncStartNetworkType_t* _ncStartNetworkType,
946
const axutil_env_t *env, axiom_element_t *parent_element,
947
axutil_hash_t *namespaces, int *next_ns_index)
950
/* Here this is an empty function, Nothing to declare */
956
axiom_node_t* AXIS2_CALL
957
adb_ncStartNetworkType_serialize(
958
adb_ncStartNetworkType_t* _ncStartNetworkType,
959
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)
963
axis2_char_t *string_to_stream;
966
axiom_node_t *current_node = NULL;
971
axiom_namespace_t *ns1 = NULL;
973
axis2_char_t *qname_uri = NULL;
974
axis2_char_t *qname_prefix = NULL;
975
axis2_char_t *p_prefix = NULL;
976
axis2_bool_t ns_already_defined;
980
void *element = NULL;
982
axis2_char_t *text_value_1;
983
axis2_char_t *text_value_1_temp;
985
axis2_char_t *text_value_2;
986
axis2_char_t *text_value_2_temp;
988
axis2_char_t text_value_3[64];
990
axis2_char_t text_value_4[64];
992
axis2_char_t *text_value_5;
993
axis2_char_t *text_value_5_temp;
995
axis2_char_t text_value_6[64];
997
axis2_char_t text_value_7[64];
999
axis2_char_t *start_input_str = NULL;
1000
axis2_char_t *end_input_str = NULL;
1001
unsigned int start_input_str_len = 0;
1002
unsigned int end_input_str_len = 0;
1005
axiom_data_source_t *data_source = NULL;
1006
axutil_stream_t *stream = NULL;
1010
AXIS2_ENV_CHECK(env, NULL);
1011
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, NULL);
1014
current_node = parent;
1015
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1018
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1022
if(!parent_tag_closed)
1025
string_to_stream = ">";
1026
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1031
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1033
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1034
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1035
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1037
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1038
"http://eucalyptus.ucsb.edu/",
1043
if (!_ncStartNetworkType->is_valid_correlationId)
1046
/* no need to complain for minoccurs=0 element */
1052
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1053
(4 + axutil_strlen(p_prefix) +
1054
axutil_strlen("correlationId")));
1056
/* axutil_strlen("<:>") + 1 = 4 */
1057
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1058
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1059
/* axutil_strlen("</:>") + 1 = 5 */
1067
* parsing correlationId element
1072
sprintf(start_input_str, "<%s%scorrelationId>",
1073
p_prefix?p_prefix:"",
1074
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1076
start_input_str_len = axutil_strlen(start_input_str);
1077
sprintf(end_input_str, "</%s%scorrelationId>",
1078
p_prefix?p_prefix:"",
1079
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1080
end_input_str_len = axutil_strlen(end_input_str);
1082
text_value_1 = _ncStartNetworkType->property_correlationId;
1084
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1087
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1088
if (text_value_1_temp)
1090
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
1091
AXIS2_FREE(env->allocator, text_value_1_temp);
1095
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1098
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1101
AXIS2_FREE(env->allocator,start_input_str);
1102
AXIS2_FREE(env->allocator,end_input_str);
1106
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1108
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1109
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1110
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1112
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1113
"http://eucalyptus.ucsb.edu/",
1118
if (!_ncStartNetworkType->is_valid_userId)
1121
/* no need to complain for minoccurs=0 element */
1127
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1128
(4 + axutil_strlen(p_prefix) +
1129
axutil_strlen("userId")));
1131
/* axutil_strlen("<:>") + 1 = 4 */
1132
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1133
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1134
/* axutil_strlen("</:>") + 1 = 5 */
1142
* parsing userId element
1147
sprintf(start_input_str, "<%s%suserId>",
1148
p_prefix?p_prefix:"",
1149
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1151
start_input_str_len = axutil_strlen(start_input_str);
1152
sprintf(end_input_str, "</%s%suserId>",
1153
p_prefix?p_prefix:"",
1154
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1155
end_input_str_len = axutil_strlen(end_input_str);
1157
text_value_2 = _ncStartNetworkType->property_userId;
1159
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1162
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1163
if (text_value_2_temp)
1165
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1166
AXIS2_FREE(env->allocator, text_value_2_temp);
1170
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1173
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1176
AXIS2_FREE(env->allocator,start_input_str);
1177
AXIS2_FREE(env->allocator,end_input_str);
1181
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1183
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1184
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1185
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1187
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1188
"http://eucalyptus.ucsb.edu/",
1193
if (!_ncStartNetworkType->is_valid_return)
1196
/* no need to complain for minoccurs=0 element */
1202
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1203
(4 + axutil_strlen(p_prefix) +
1204
axutil_strlen("return")));
1206
/* axutil_strlen("<:>") + 1 = 4 */
1207
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1208
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1209
/* axutil_strlen("</:>") + 1 = 5 */
1217
* parsing return element
1222
sprintf(start_input_str, "<%s%sreturn>",
1223
p_prefix?p_prefix:"",
1224
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1226
start_input_str_len = axutil_strlen(start_input_str);
1227
sprintf(end_input_str, "</%s%sreturn>",
1228
p_prefix?p_prefix:"",
1229
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1230
end_input_str_len = axutil_strlen(end_input_str);
1232
strcpy(text_value_3, (_ncStartNetworkType->property_return)?"true":"false");
1234
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1236
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1238
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1241
AXIS2_FREE(env->allocator,start_input_str);
1242
AXIS2_FREE(env->allocator,end_input_str);
1246
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1248
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1249
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1250
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1252
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1253
"http://eucalyptus.ucsb.edu/",
1258
if (!_ncStartNetworkType->is_valid_statusMessage)
1261
/* no need to complain for minoccurs=0 element */
1267
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1268
(4 + axutil_strlen(p_prefix) +
1269
axutil_strlen("statusMessage")));
1271
/* axutil_strlen("<:>") + 1 = 4 */
1272
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1273
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1274
/* axutil_strlen("</:>") + 1 = 5 */
1282
* parsing statusMessage element
1287
sprintf(start_input_str, "<%s%sstatusMessage>",
1288
p_prefix?p_prefix:"",
1289
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1291
start_input_str_len = axutil_strlen(start_input_str);
1292
sprintf(end_input_str, "</%s%sstatusMessage>",
1293
p_prefix?p_prefix:"",
1294
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1295
end_input_str_len = axutil_strlen(end_input_str);
1297
sprintf (text_value_4, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncStartNetworkType->property_statusMessage);
1299
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1301
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1303
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1306
AXIS2_FREE(env->allocator,start_input_str);
1307
AXIS2_FREE(env->allocator,end_input_str);
1311
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1313
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1314
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1315
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1317
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1318
"http://eucalyptus.ucsb.edu/",
1323
if (!_ncStartNetworkType->is_valid_remoteHosts)
1326
/* no need to complain for minoccurs=0 element */
1332
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1333
(4 + axutil_strlen(p_prefix) +
1334
axutil_strlen("remoteHosts")));
1336
/* axutil_strlen("<:>") + 1 = 4 */
1337
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1338
(5 + axutil_strlen(p_prefix) + axutil_strlen("remoteHosts")));
1339
/* axutil_strlen("</:>") + 1 = 5 */
1346
* Parsing remoteHosts array
1348
if (_ncStartNetworkType->property_remoteHosts != NULL)
1351
sprintf(start_input_str, "<%s%sremoteHosts>",
1352
p_prefix?p_prefix:"",
1353
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1355
start_input_str_len = axutil_strlen(start_input_str);
1357
sprintf(end_input_str, "</%s%sremoteHosts>",
1358
p_prefix?p_prefix:"",
1359
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1360
end_input_str_len = axutil_strlen(end_input_str);
1362
count = axutil_array_list_size(_ncStartNetworkType->property_remoteHosts, env);
1363
for(i = 0; i < count; i ++)
1365
element = axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i);
1374
* parsing remoteHosts element
1379
text_value_5 = (axis2_char_t*)element;
1381
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1384
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1385
if (text_value_5_temp)
1387
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1388
AXIS2_FREE(env->allocator, text_value_5_temp);
1392
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1395
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1401
AXIS2_FREE(env->allocator,start_input_str);
1402
AXIS2_FREE(env->allocator,end_input_str);
1406
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1408
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1409
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1410
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1412
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1413
"http://eucalyptus.ucsb.edu/",
1418
if (!_ncStartNetworkType->is_valid_remoteHostPort)
1421
/* no need to complain for minoccurs=0 element */
1427
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1428
(4 + axutil_strlen(p_prefix) +
1429
axutil_strlen("remoteHostPort")));
1431
/* axutil_strlen("<:>") + 1 = 4 */
1432
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1433
(5 + axutil_strlen(p_prefix) + axutil_strlen("remoteHostPort")));
1434
/* axutil_strlen("</:>") + 1 = 5 */
1442
* parsing remoteHostPort element
1447
sprintf(start_input_str, "<%s%sremoteHostPort>",
1448
p_prefix?p_prefix:"",
1449
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1451
start_input_str_len = axutil_strlen(start_input_str);
1452
sprintf(end_input_str, "</%s%sremoteHostPort>",
1453
p_prefix?p_prefix:"",
1454
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1455
end_input_str_len = axutil_strlen(end_input_str);
1457
sprintf (text_value_6, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncStartNetworkType->property_remoteHostPort);
1459
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1461
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1463
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1466
AXIS2_FREE(env->allocator,start_input_str);
1467
AXIS2_FREE(env->allocator,end_input_str);
1471
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1473
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1474
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1475
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1477
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1478
"http://eucalyptus.ucsb.edu/",
1483
if (!_ncStartNetworkType->is_valid_vlan)
1486
/* no need to complain for minoccurs=0 element */
1492
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1493
(4 + axutil_strlen(p_prefix) +
1494
axutil_strlen("vlan")));
1496
/* axutil_strlen("<:>") + 1 = 4 */
1497
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1498
(5 + axutil_strlen(p_prefix) + axutil_strlen("vlan")));
1499
/* axutil_strlen("</:>") + 1 = 5 */
1507
* parsing vlan element
1512
sprintf(start_input_str, "<%s%svlan>",
1513
p_prefix?p_prefix:"",
1514
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1516
start_input_str_len = axutil_strlen(start_input_str);
1517
sprintf(end_input_str, "</%s%svlan>",
1518
p_prefix?p_prefix:"",
1519
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1520
end_input_str_len = axutil_strlen(end_input_str);
1522
sprintf (text_value_7, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncStartNetworkType->property_vlan);
1524
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1526
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1528
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1531
AXIS2_FREE(env->allocator,start_input_str);
1532
AXIS2_FREE(env->allocator,end_input_str);
1544
* getter for correlationId.
1546
axis2_char_t* AXIS2_CALL
1547
adb_ncStartNetworkType_get_correlationId(
1548
adb_ncStartNetworkType_t* _ncStartNetworkType,
1549
const axutil_env_t *env)
1552
AXIS2_ENV_CHECK(env, NULL);
1553
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, NULL);
1556
return _ncStartNetworkType->property_correlationId;
1560
* setter for correlationId
1562
axis2_status_t AXIS2_CALL
1563
adb_ncStartNetworkType_set_correlationId(
1564
adb_ncStartNetworkType_t* _ncStartNetworkType,
1565
const axutil_env_t *env,
1566
const axis2_char_t* arg_correlationId)
1570
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1571
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1573
if(_ncStartNetworkType->is_valid_correlationId &&
1574
arg_correlationId == _ncStartNetworkType->property_correlationId)
1577
return AXIS2_SUCCESS;
1580
adb_ncStartNetworkType_reset_correlationId(_ncStartNetworkType, env);
1583
if(NULL == arg_correlationId)
1585
/* We are already done */
1586
return AXIS2_SUCCESS;
1588
_ncStartNetworkType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1589
if(NULL == _ncStartNetworkType->property_correlationId)
1591
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1592
return AXIS2_FAILURE;
1594
_ncStartNetworkType->is_valid_correlationId = AXIS2_TRUE;
1596
return AXIS2_SUCCESS;
1602
* resetter for correlationId
1604
axis2_status_t AXIS2_CALL
1605
adb_ncStartNetworkType_reset_correlationId(
1606
adb_ncStartNetworkType_t* _ncStartNetworkType,
1607
const axutil_env_t *env)
1611
void *element = NULL;
1613
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1614
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1620
if(_ncStartNetworkType->property_correlationId != NULL)
1624
AXIS2_FREE(env-> allocator, _ncStartNetworkType->property_correlationId);
1625
_ncStartNetworkType->property_correlationId = NULL;
1630
_ncStartNetworkType->is_valid_correlationId = AXIS2_FALSE;
1631
return AXIS2_SUCCESS;
1635
* Check whether correlationId is nill
1637
axis2_bool_t AXIS2_CALL
1638
adb_ncStartNetworkType_is_correlationId_nil(
1639
adb_ncStartNetworkType_t* _ncStartNetworkType,
1640
const axutil_env_t *env)
1642
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1643
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
1645
return !_ncStartNetworkType->is_valid_correlationId;
1649
* Set correlationId to nill (currently the same as reset)
1651
axis2_status_t AXIS2_CALL
1652
adb_ncStartNetworkType_set_correlationId_nil(
1653
adb_ncStartNetworkType_t* _ncStartNetworkType,
1654
const axutil_env_t *env)
1656
return adb_ncStartNetworkType_reset_correlationId(_ncStartNetworkType, env);
1662
* getter for userId.
1664
axis2_char_t* AXIS2_CALL
1665
adb_ncStartNetworkType_get_userId(
1666
adb_ncStartNetworkType_t* _ncStartNetworkType,
1667
const axutil_env_t *env)
1670
AXIS2_ENV_CHECK(env, NULL);
1671
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, NULL);
1674
return _ncStartNetworkType->property_userId;
1680
axis2_status_t AXIS2_CALL
1681
adb_ncStartNetworkType_set_userId(
1682
adb_ncStartNetworkType_t* _ncStartNetworkType,
1683
const axutil_env_t *env,
1684
const axis2_char_t* arg_userId)
1688
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1689
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1691
if(_ncStartNetworkType->is_valid_userId &&
1692
arg_userId == _ncStartNetworkType->property_userId)
1695
return AXIS2_SUCCESS;
1698
adb_ncStartNetworkType_reset_userId(_ncStartNetworkType, env);
1701
if(NULL == arg_userId)
1703
/* We are already done */
1704
return AXIS2_SUCCESS;
1706
_ncStartNetworkType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1707
if(NULL == _ncStartNetworkType->property_userId)
1709
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1710
return AXIS2_FAILURE;
1712
_ncStartNetworkType->is_valid_userId = AXIS2_TRUE;
1714
return AXIS2_SUCCESS;
1720
* resetter for userId
1722
axis2_status_t AXIS2_CALL
1723
adb_ncStartNetworkType_reset_userId(
1724
adb_ncStartNetworkType_t* _ncStartNetworkType,
1725
const axutil_env_t *env)
1729
void *element = NULL;
1731
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1732
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1738
if(_ncStartNetworkType->property_userId != NULL)
1742
AXIS2_FREE(env-> allocator, _ncStartNetworkType->property_userId);
1743
_ncStartNetworkType->property_userId = NULL;
1748
_ncStartNetworkType->is_valid_userId = AXIS2_FALSE;
1749
return AXIS2_SUCCESS;
1753
* Check whether userId is nill
1755
axis2_bool_t AXIS2_CALL
1756
adb_ncStartNetworkType_is_userId_nil(
1757
adb_ncStartNetworkType_t* _ncStartNetworkType,
1758
const axutil_env_t *env)
1760
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1761
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
1763
return !_ncStartNetworkType->is_valid_userId;
1767
* Set userId to nill (currently the same as reset)
1769
axis2_status_t AXIS2_CALL
1770
adb_ncStartNetworkType_set_userId_nil(
1771
adb_ncStartNetworkType_t* _ncStartNetworkType,
1772
const axutil_env_t *env)
1774
return adb_ncStartNetworkType_reset_userId(_ncStartNetworkType, env);
1780
* getter for return.
1782
axis2_bool_t AXIS2_CALL
1783
adb_ncStartNetworkType_get_return(
1784
adb_ncStartNetworkType_t* _ncStartNetworkType,
1785
const axutil_env_t *env)
1788
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1789
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, (axis2_bool_t)0);
1792
return _ncStartNetworkType->property_return;
1798
axis2_status_t AXIS2_CALL
1799
adb_ncStartNetworkType_set_return(
1800
adb_ncStartNetworkType_t* _ncStartNetworkType,
1801
const axutil_env_t *env,
1802
axis2_bool_t arg_return)
1806
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1807
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1809
if(_ncStartNetworkType->is_valid_return &&
1810
arg_return == _ncStartNetworkType->property_return)
1813
return AXIS2_SUCCESS;
1816
adb_ncStartNetworkType_reset_return(_ncStartNetworkType, env);
1818
_ncStartNetworkType->property_return = arg_return;
1819
_ncStartNetworkType->is_valid_return = AXIS2_TRUE;
1821
return AXIS2_SUCCESS;
1827
* resetter for return
1829
axis2_status_t AXIS2_CALL
1830
adb_ncStartNetworkType_reset_return(
1831
adb_ncStartNetworkType_t* _ncStartNetworkType,
1832
const axutil_env_t *env)
1836
void *element = NULL;
1838
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1839
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1842
_ncStartNetworkType->is_valid_return = AXIS2_FALSE;
1843
return AXIS2_SUCCESS;
1847
* Check whether return is nill
1849
axis2_bool_t AXIS2_CALL
1850
adb_ncStartNetworkType_is_return_nil(
1851
adb_ncStartNetworkType_t* _ncStartNetworkType,
1852
const axutil_env_t *env)
1854
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1855
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
1857
return !_ncStartNetworkType->is_valid_return;
1861
* Set return to nill (currently the same as reset)
1863
axis2_status_t AXIS2_CALL
1864
adb_ncStartNetworkType_set_return_nil(
1865
adb_ncStartNetworkType_t* _ncStartNetworkType,
1866
const axutil_env_t *env)
1868
return adb_ncStartNetworkType_reset_return(_ncStartNetworkType, env);
1874
* getter for statusMessage.
1877
adb_ncStartNetworkType_get_statusMessage(
1878
adb_ncStartNetworkType_t* _ncStartNetworkType,
1879
const axutil_env_t *env)
1882
AXIS2_ENV_CHECK(env, (int)0);
1883
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, (int)0);
1886
return _ncStartNetworkType->property_statusMessage;
1890
* setter for statusMessage
1892
axis2_status_t AXIS2_CALL
1893
adb_ncStartNetworkType_set_statusMessage(
1894
adb_ncStartNetworkType_t* _ncStartNetworkType,
1895
const axutil_env_t *env,
1896
const int arg_statusMessage)
1900
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1901
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1903
if(_ncStartNetworkType->is_valid_statusMessage &&
1904
arg_statusMessage == _ncStartNetworkType->property_statusMessage)
1907
return AXIS2_SUCCESS;
1910
adb_ncStartNetworkType_reset_statusMessage(_ncStartNetworkType, env);
1912
_ncStartNetworkType->property_statusMessage = arg_statusMessage;
1913
_ncStartNetworkType->is_valid_statusMessage = AXIS2_TRUE;
1915
return AXIS2_SUCCESS;
1921
* resetter for statusMessage
1923
axis2_status_t AXIS2_CALL
1924
adb_ncStartNetworkType_reset_statusMessage(
1925
adb_ncStartNetworkType_t* _ncStartNetworkType,
1926
const axutil_env_t *env)
1930
void *element = NULL;
1932
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1933
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
1936
_ncStartNetworkType->is_valid_statusMessage = AXIS2_FALSE;
1937
return AXIS2_SUCCESS;
1941
* Check whether statusMessage is nill
1943
axis2_bool_t AXIS2_CALL
1944
adb_ncStartNetworkType_is_statusMessage_nil(
1945
adb_ncStartNetworkType_t* _ncStartNetworkType,
1946
const axutil_env_t *env)
1948
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1949
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
1951
return !_ncStartNetworkType->is_valid_statusMessage;
1955
* Set statusMessage to nill (currently the same as reset)
1957
axis2_status_t AXIS2_CALL
1958
adb_ncStartNetworkType_set_statusMessage_nil(
1959
adb_ncStartNetworkType_t* _ncStartNetworkType,
1960
const axutil_env_t *env)
1962
return adb_ncStartNetworkType_reset_statusMessage(_ncStartNetworkType, env);
1968
* getter for remoteHosts.
1970
axutil_array_list_t* AXIS2_CALL
1971
adb_ncStartNetworkType_get_remoteHosts(
1972
adb_ncStartNetworkType_t* _ncStartNetworkType,
1973
const axutil_env_t *env)
1976
AXIS2_ENV_CHECK(env, NULL);
1977
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, NULL);
1980
return _ncStartNetworkType->property_remoteHosts;
1984
* setter for remoteHosts
1986
axis2_status_t AXIS2_CALL
1987
adb_ncStartNetworkType_set_remoteHosts(
1988
adb_ncStartNetworkType_t* _ncStartNetworkType,
1989
const axutil_env_t *env,
1990
axutil_array_list_t* arg_remoteHosts)
1995
axis2_bool_t non_nil_exists = AXIS2_FALSE;
1998
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1999
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2001
if(_ncStartNetworkType->is_valid_remoteHosts &&
2002
arg_remoteHosts == _ncStartNetworkType->property_remoteHosts)
2005
return AXIS2_SUCCESS;
2009
size = axutil_array_list_size(arg_remoteHosts, env);
2013
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "remoteHosts has less than minOccurs(0)");
2014
return AXIS2_FAILURE;
2016
for(i = 0; i < size; i ++ )
2018
if(NULL != axutil_array_list_get(arg_remoteHosts, env, i))
2020
non_nil_exists = AXIS2_TRUE;
2025
adb_ncStartNetworkType_reset_remoteHosts(_ncStartNetworkType, env);
2028
if(NULL == arg_remoteHosts)
2030
/* We are already done */
2031
return AXIS2_SUCCESS;
2033
_ncStartNetworkType->property_remoteHosts = arg_remoteHosts;
2036
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_TRUE;
2040
return AXIS2_SUCCESS;
2045
* Get ith element of remoteHosts.
2047
axis2_char_t* AXIS2_CALL
2048
adb_ncStartNetworkType_get_remoteHosts_at(
2049
adb_ncStartNetworkType_t* _ncStartNetworkType,
2050
const axutil_env_t *env, int i)
2052
axis2_char_t* ret_val;
2055
AXIS2_ENV_CHECK(env, NULL);
2056
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, NULL);
2059
if(_ncStartNetworkType->property_remoteHosts == NULL)
2061
return (axis2_char_t*)0;
2063
ret_val = (axis2_char_t*)axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i);
2070
* Set the ith element of remoteHosts.
2072
axis2_status_t AXIS2_CALL
2073
adb_ncStartNetworkType_set_remoteHosts_at(
2074
adb_ncStartNetworkType_t* _ncStartNetworkType,
2075
const axutil_env_t *env, int i,
2076
const axis2_char_t* arg_remoteHosts)
2078
void *element = NULL;
2082
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2086
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2087
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2089
if( _ncStartNetworkType->is_valid_remoteHosts &&
2090
_ncStartNetworkType->property_remoteHosts &&
2092
arg_remoteHosts == (axis2_char_t*)axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i))
2096
return AXIS2_SUCCESS;
2100
if(NULL == arg_remoteHosts)
2102
if(_ncStartNetworkType->property_remoteHosts != NULL)
2104
size = axutil_array_list_size(_ncStartNetworkType->property_remoteHosts, env);
2105
for(j = 0, k = 0; j < size; j ++ )
2107
if(i == j) continue;
2108
if(NULL != axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i))
2111
non_nil_exists = AXIS2_TRUE;
2122
non_nil_exists = AXIS2_TRUE;
2127
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of remoteHosts is beinng set to be smaller than the specificed number of minOccurs(0)");
2128
return AXIS2_FAILURE;
2131
if(_ncStartNetworkType->property_remoteHosts == NULL)
2133
_ncStartNetworkType->property_remoteHosts = axutil_array_list_create(env, 10);
2136
/* check whether there already exist an element */
2137
element = axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i);
2143
/* This is an unknown type or a primitive. Please free this manually*/
2151
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_FALSE;
2152
axutil_array_list_set(_ncStartNetworkType->property_remoteHosts , env, i, NULL);
2154
return AXIS2_SUCCESS;
2157
axutil_array_list_set(_ncStartNetworkType->property_remoteHosts , env, i, axutil_strdup(env, arg_remoteHosts));
2158
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_TRUE;
2160
return AXIS2_SUCCESS;
2164
* Add to remoteHosts.
2166
axis2_status_t AXIS2_CALL
2167
adb_ncStartNetworkType_add_remoteHosts(
2168
adb_ncStartNetworkType_t* _ncStartNetworkType,
2169
const axutil_env_t *env,
2170
const axis2_char_t* arg_remoteHosts)
2174
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2175
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2178
if(NULL == arg_remoteHosts)
2181
return AXIS2_SUCCESS;
2186
if(_ncStartNetworkType->property_remoteHosts == NULL)
2188
_ncStartNetworkType->property_remoteHosts = axutil_array_list_create(env, 10);
2190
if(_ncStartNetworkType->property_remoteHosts == NULL)
2192
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for remoteHosts");
2193
return AXIS2_FAILURE;
2197
axutil_array_list_add(_ncStartNetworkType->property_remoteHosts , env, axutil_strdup(env, arg_remoteHosts));
2198
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_TRUE;
2199
return AXIS2_SUCCESS;
2203
* Get the size of the remoteHosts array.
2206
adb_ncStartNetworkType_sizeof_remoteHosts(
2207
adb_ncStartNetworkType_t* _ncStartNetworkType,
2208
const axutil_env_t *env)
2210
AXIS2_ENV_CHECK(env, -1);
2211
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, -1);
2212
if(_ncStartNetworkType->property_remoteHosts == NULL)
2216
return axutil_array_list_size(_ncStartNetworkType->property_remoteHosts, env);
2220
* remove the ith element, same as set_nil_at.
2222
axis2_status_t AXIS2_CALL
2223
adb_ncStartNetworkType_remove_remoteHosts_at(
2224
adb_ncStartNetworkType_t* _ncStartNetworkType,
2225
const axutil_env_t *env, int i)
2227
return adb_ncStartNetworkType_set_remoteHosts_nil_at(_ncStartNetworkType, env, i);
2233
* resetter for remoteHosts
2235
axis2_status_t AXIS2_CALL
2236
adb_ncStartNetworkType_reset_remoteHosts(
2237
adb_ncStartNetworkType_t* _ncStartNetworkType,
2238
const axutil_env_t *env)
2242
void *element = NULL;
2244
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2245
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2249
if (_ncStartNetworkType->property_remoteHosts != NULL)
2251
count = axutil_array_list_size(_ncStartNetworkType->property_remoteHosts, env);
2252
for(i = 0; i < count; i ++)
2254
element = axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i);
2262
AXIS2_FREE(env-> allocator, (axis2_char_t*)element);
2270
axutil_array_list_free(_ncStartNetworkType->property_remoteHosts, env);
2272
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_FALSE;
2273
return AXIS2_SUCCESS;
2277
* Check whether remoteHosts is nill
2279
axis2_bool_t AXIS2_CALL
2280
adb_ncStartNetworkType_is_remoteHosts_nil(
2281
adb_ncStartNetworkType_t* _ncStartNetworkType,
2282
const axutil_env_t *env)
2284
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2285
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
2287
return !_ncStartNetworkType->is_valid_remoteHosts;
2291
* Set remoteHosts to nill (currently the same as reset)
2293
axis2_status_t AXIS2_CALL
2294
adb_ncStartNetworkType_set_remoteHosts_nil(
2295
adb_ncStartNetworkType_t* _ncStartNetworkType,
2296
const axutil_env_t *env)
2298
return adb_ncStartNetworkType_reset_remoteHosts(_ncStartNetworkType, env);
2303
* Check whether remoteHosts is nill at i
2305
axis2_bool_t AXIS2_CALL
2306
adb_ncStartNetworkType_is_remoteHosts_nil_at(
2307
adb_ncStartNetworkType_t* _ncStartNetworkType,
2308
const axutil_env_t *env, int i)
2310
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2311
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
2313
return (_ncStartNetworkType->is_valid_remoteHosts == AXIS2_FALSE ||
2314
NULL == _ncStartNetworkType->property_remoteHosts ||
2315
NULL == axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i));
2319
* Set remoteHosts to nill at i
2321
axis2_status_t AXIS2_CALL
2322
adb_ncStartNetworkType_set_remoteHosts_nil_at(
2323
adb_ncStartNetworkType_t* _ncStartNetworkType,
2324
const axutil_env_t *env, int i)
2326
void *element = NULL;
2329
axis2_bool_t non_nil_exists = AXIS2_FALSE;
2333
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2334
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2336
if(_ncStartNetworkType->property_remoteHosts == NULL ||
2337
_ncStartNetworkType->is_valid_remoteHosts == AXIS2_FALSE)
2340
non_nil_exists = AXIS2_FALSE;
2344
size = axutil_array_list_size(_ncStartNetworkType->property_remoteHosts, env);
2345
for(j = 0, k = 0; j < size; j ++ )
2347
if(i == j) continue;
2348
if(NULL != axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i))
2351
non_nil_exists = AXIS2_TRUE;
2363
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of remoteHosts is beinng set to be smaller than the specificed number of minOccurs(0)");
2364
return AXIS2_FAILURE;
2367
if(_ncStartNetworkType->property_remoteHosts == NULL)
2369
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_FALSE;
2371
return AXIS2_SUCCESS;
2374
/* check whether there already exist an element */
2375
element = axutil_array_list_get(_ncStartNetworkType->property_remoteHosts, env, i);
2381
/* This is an unknown type or a primitive. Please free this manually*/
2389
_ncStartNetworkType->is_valid_remoteHosts = AXIS2_FALSE;
2390
axutil_array_list_set(_ncStartNetworkType->property_remoteHosts , env, i, NULL);
2391
return AXIS2_SUCCESS;
2396
axutil_array_list_set(_ncStartNetworkType->property_remoteHosts , env, i, NULL);
2398
return AXIS2_SUCCESS;
2405
* getter for remoteHostPort.
2408
adb_ncStartNetworkType_get_remoteHostPort(
2409
adb_ncStartNetworkType_t* _ncStartNetworkType,
2410
const axutil_env_t *env)
2413
AXIS2_ENV_CHECK(env, (int)0);
2414
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, (int)0);
2417
return _ncStartNetworkType->property_remoteHostPort;
2421
* setter for remoteHostPort
2423
axis2_status_t AXIS2_CALL
2424
adb_ncStartNetworkType_set_remoteHostPort(
2425
adb_ncStartNetworkType_t* _ncStartNetworkType,
2426
const axutil_env_t *env,
2427
const int arg_remoteHostPort)
2431
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2432
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2434
if(_ncStartNetworkType->is_valid_remoteHostPort &&
2435
arg_remoteHostPort == _ncStartNetworkType->property_remoteHostPort)
2438
return AXIS2_SUCCESS;
2441
adb_ncStartNetworkType_reset_remoteHostPort(_ncStartNetworkType, env);
2443
_ncStartNetworkType->property_remoteHostPort = arg_remoteHostPort;
2444
_ncStartNetworkType->is_valid_remoteHostPort = AXIS2_TRUE;
2446
return AXIS2_SUCCESS;
2452
* resetter for remoteHostPort
2454
axis2_status_t AXIS2_CALL
2455
adb_ncStartNetworkType_reset_remoteHostPort(
2456
adb_ncStartNetworkType_t* _ncStartNetworkType,
2457
const axutil_env_t *env)
2461
void *element = NULL;
2463
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2464
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2467
_ncStartNetworkType->is_valid_remoteHostPort = AXIS2_FALSE;
2468
return AXIS2_SUCCESS;
2472
* Check whether remoteHostPort is nill
2474
axis2_bool_t AXIS2_CALL
2475
adb_ncStartNetworkType_is_remoteHostPort_nil(
2476
adb_ncStartNetworkType_t* _ncStartNetworkType,
2477
const axutil_env_t *env)
2479
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2480
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
2482
return !_ncStartNetworkType->is_valid_remoteHostPort;
2486
* Set remoteHostPort to nill (currently the same as reset)
2488
axis2_status_t AXIS2_CALL
2489
adb_ncStartNetworkType_set_remoteHostPort_nil(
2490
adb_ncStartNetworkType_t* _ncStartNetworkType,
2491
const axutil_env_t *env)
2493
return adb_ncStartNetworkType_reset_remoteHostPort(_ncStartNetworkType, env);
2502
adb_ncStartNetworkType_get_vlan(
2503
adb_ncStartNetworkType_t* _ncStartNetworkType,
2504
const axutil_env_t *env)
2507
AXIS2_ENV_CHECK(env, (int)0);
2508
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, (int)0);
2511
return _ncStartNetworkType->property_vlan;
2517
axis2_status_t AXIS2_CALL
2518
adb_ncStartNetworkType_set_vlan(
2519
adb_ncStartNetworkType_t* _ncStartNetworkType,
2520
const axutil_env_t *env,
2525
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2526
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2528
if(_ncStartNetworkType->is_valid_vlan &&
2529
arg_vlan == _ncStartNetworkType->property_vlan)
2532
return AXIS2_SUCCESS;
2535
adb_ncStartNetworkType_reset_vlan(_ncStartNetworkType, env);
2537
_ncStartNetworkType->property_vlan = arg_vlan;
2538
_ncStartNetworkType->is_valid_vlan = AXIS2_TRUE;
2540
return AXIS2_SUCCESS;
2548
axis2_status_t AXIS2_CALL
2549
adb_ncStartNetworkType_reset_vlan(
2550
adb_ncStartNetworkType_t* _ncStartNetworkType,
2551
const axutil_env_t *env)
2555
void *element = NULL;
2557
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2558
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_FAILURE);
2561
_ncStartNetworkType->is_valid_vlan = AXIS2_FALSE;
2562
return AXIS2_SUCCESS;
2566
* Check whether vlan is nill
2568
axis2_bool_t AXIS2_CALL
2569
adb_ncStartNetworkType_is_vlan_nil(
2570
adb_ncStartNetworkType_t* _ncStartNetworkType,
2571
const axutil_env_t *env)
2573
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2574
AXIS2_PARAM_CHECK(env->error, _ncStartNetworkType, AXIS2_TRUE);
2576
return !_ncStartNetworkType->is_valid_vlan;
2580
* Set vlan to nill (currently the same as reset)
2582
axis2_status_t AXIS2_CALL
2583
adb_ncStartNetworkType_set_vlan_nil(
2584
adb_ncStartNetworkType_t* _ncStartNetworkType,
2585
const axutil_env_t *env)
2587
return adb_ncStartNetworkType_reset_vlan(_ncStartNetworkType, env);
added
removed
cluster/generated/adb_ncStartNetworkType.c
