4
* adb_stopNetworkType.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_stopNetworkType.h"
13
* This type was generated from the piece of schema that had
14
* name = stopNetworkType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_stopNetworkType
23
axis2_char_t* property_correlationId;
26
axis2_bool_t is_valid_correlationId;
29
axis2_char_t* property_userId;
32
axis2_bool_t is_valid_userId;
35
axis2_char_t* property_statusMessage;
38
axis2_bool_t is_valid_statusMessage;
41
axis2_bool_t property_return;
44
axis2_bool_t is_valid_return;
50
axis2_bool_t is_valid_vlan;
53
axis2_char_t* property_netName;
56
axis2_bool_t is_valid_netName;
63
/************************* Private Function prototypes ********************************/
66
axis2_status_t AXIS2_CALL
67
adb_stopNetworkType_set_correlationId_nil(
68
adb_stopNetworkType_t* _stopNetworkType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_stopNetworkType_set_userId_nil(
74
adb_stopNetworkType_t* _stopNetworkType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_stopNetworkType_set_return_nil(
80
adb_stopNetworkType_t* _stopNetworkType,
81
const axutil_env_t *env);
84
axis2_status_t AXIS2_CALL
85
adb_stopNetworkType_set_vlan_nil(
86
adb_stopNetworkType_t* _stopNetworkType,
87
const axutil_env_t *env);
90
axis2_status_t AXIS2_CALL
91
adb_stopNetworkType_set_netName_nil(
92
adb_stopNetworkType_t* _stopNetworkType,
93
const axutil_env_t *env);
97
/************************* Function Implmentations ********************************/
98
adb_stopNetworkType_t* AXIS2_CALL
99
adb_stopNetworkType_create(
100
const axutil_env_t *env)
102
adb_stopNetworkType_t *_stopNetworkType = NULL;
104
AXIS2_ENV_CHECK(env, NULL);
106
_stopNetworkType = (adb_stopNetworkType_t *) AXIS2_MALLOC(env->
107
allocator, sizeof(adb_stopNetworkType_t));
109
if(NULL == _stopNetworkType)
111
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
115
memset(_stopNetworkType, 0, sizeof(adb_stopNetworkType_t));
117
_stopNetworkType->property_correlationId = NULL;
118
_stopNetworkType->is_valid_correlationId = AXIS2_FALSE;
119
_stopNetworkType->property_userId = NULL;
120
_stopNetworkType->is_valid_userId = AXIS2_FALSE;
121
_stopNetworkType->property_statusMessage = NULL;
122
_stopNetworkType->is_valid_statusMessage = AXIS2_FALSE;
123
_stopNetworkType->is_valid_return = AXIS2_FALSE;
124
_stopNetworkType->is_valid_vlan = AXIS2_FALSE;
125
_stopNetworkType->property_netName = NULL;
126
_stopNetworkType->is_valid_netName = AXIS2_FALSE;
129
return _stopNetworkType;
132
axis2_status_t AXIS2_CALL
133
adb_stopNetworkType_free (
134
adb_stopNetworkType_t* _stopNetworkType,
135
const axutil_env_t *env)
139
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
140
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
142
adb_stopNetworkType_reset_correlationId(_stopNetworkType, env);
143
adb_stopNetworkType_reset_userId(_stopNetworkType, env);
144
adb_stopNetworkType_reset_statusMessage(_stopNetworkType, env);
145
adb_stopNetworkType_reset_return(_stopNetworkType, env);
146
adb_stopNetworkType_reset_vlan(_stopNetworkType, env);
147
adb_stopNetworkType_reset_netName(_stopNetworkType, env);
152
AXIS2_FREE(env->allocator, _stopNetworkType);
153
_stopNetworkType = NULL;
155
return AXIS2_SUCCESS;
161
axis2_status_t AXIS2_CALL
162
adb_stopNetworkType_deserialize(
163
adb_stopNetworkType_t* _stopNetworkType,
164
const axutil_env_t *env,
165
axiom_node_t **dp_parent,
166
axis2_bool_t *dp_is_early_node_valid,
167
axis2_bool_t dont_care_minoccurs)
169
axiom_node_t *parent = *dp_parent;
171
axis2_status_t status = AXIS2_SUCCESS;
173
axis2_char_t* text_value = NULL;
174
axutil_qname_t *qname = NULL;
176
axutil_qname_t *element_qname = NULL;
178
axiom_node_t *first_node = NULL;
179
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
180
axiom_node_t *current_node = NULL;
181
axiom_element_t *current_element = NULL;
183
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
184
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
188
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
190
parent = axiom_node_get_next_sibling(parent, env);
194
/* This should be checked before everything */
195
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
196
"Failed in building adb object for stopNetworkType : "
197
"NULL elemenet can not be passed to deserialize");
198
return AXIS2_FAILURE;
202
first_node = axiom_node_get_first_child(parent, env);
208
* building correlationId element
213
current_node = first_node;
214
is_early_node_valid = AXIS2_FALSE;
217
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
219
current_node = axiom_node_get_next_sibling(current_node, env);
221
if(current_node != NULL)
223
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
224
qname = axiom_element_get_qname(current_element, env, current_node);
227
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
231
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
233
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
235
is_early_node_valid = AXIS2_TRUE;
239
text_value = axiom_element_get_text(current_element, env, current_node);
240
if(text_value != NULL)
242
status = adb_stopNetworkType_set_correlationId(_stopNetworkType, env,
249
* axis2_qname_t *qname = NULL;
250
* axiom_attribute_t *the_attri = NULL;
252
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
253
* the_attri = axiom_element_get_attribute(current_element, env, qname);
255
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
257
axiom_attribute_t *the_attri = NULL;
258
axis2_char_t *attrib_text = NULL;
259
axutil_hash_t *attribute_hash = NULL;
261
attribute_hash = axiom_element_get_all_attributes(current_element, env);
266
axutil_hash_index_t *hi;
270
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
272
axutil_hash_this(hi, &key, NULL, &val);
274
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
276
the_attri = (axiom_attribute_t*)val;
284
attrib_text = axiom_attribute_get_value(the_attri, env);
288
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
289
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
292
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
294
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
295
status = AXIS2_FAILURE;
299
/* after all, we found this is a empty string */
300
status = adb_stopNetworkType_set_correlationId(_stopNetworkType, env,
305
if(AXIS2_FAILURE == status)
307
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
310
axutil_qname_free(element_qname, env);
312
return AXIS2_FAILURE;
318
axutil_qname_free(element_qname, env);
319
element_qname = NULL;
325
* building userId element
331
* because elements are ordered this works fine
335
if(current_node != NULL && is_early_node_valid)
337
current_node = axiom_node_get_next_sibling(current_node, env);
340
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
342
current_node = axiom_node_get_next_sibling(current_node, env);
344
if(current_node != NULL)
346
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
347
qname = axiom_element_get_qname(current_element, env, current_node);
351
is_early_node_valid = AXIS2_FALSE;
353
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
357
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
359
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
361
is_early_node_valid = AXIS2_TRUE;
365
text_value = axiom_element_get_text(current_element, env, current_node);
366
if(text_value != NULL)
368
status = adb_stopNetworkType_set_userId(_stopNetworkType, env,
375
* axis2_qname_t *qname = NULL;
376
* axiom_attribute_t *the_attri = NULL;
378
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
379
* the_attri = axiom_element_get_attribute(current_element, env, qname);
381
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
383
axiom_attribute_t *the_attri = NULL;
384
axis2_char_t *attrib_text = NULL;
385
axutil_hash_t *attribute_hash = NULL;
387
attribute_hash = axiom_element_get_all_attributes(current_element, env);
392
axutil_hash_index_t *hi;
396
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
398
axutil_hash_this(hi, &key, NULL, &val);
400
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
402
the_attri = (axiom_attribute_t*)val;
410
attrib_text = axiom_attribute_get_value(the_attri, env);
414
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
415
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
418
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
420
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
421
status = AXIS2_FAILURE;
425
/* after all, we found this is a empty string */
426
status = adb_stopNetworkType_set_userId(_stopNetworkType, env,
431
if(AXIS2_FAILURE == status)
433
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
436
axutil_qname_free(element_qname, env);
438
return AXIS2_FAILURE;
444
axutil_qname_free(element_qname, env);
445
element_qname = NULL;
451
* building statusMessage element
457
* because elements are ordered this works fine
461
if(current_node != NULL && is_early_node_valid)
463
current_node = axiom_node_get_next_sibling(current_node, env);
466
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
468
current_node = axiom_node_get_next_sibling(current_node, env);
470
if(current_node != NULL)
472
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
473
qname = axiom_element_get_qname(current_element, env, current_node);
477
is_early_node_valid = AXIS2_FALSE;
479
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
483
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
485
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
487
is_early_node_valid = AXIS2_TRUE;
491
text_value = axiom_element_get_text(current_element, env, current_node);
492
if(text_value != NULL)
494
status = adb_stopNetworkType_set_statusMessage(_stopNetworkType, env,
498
if(AXIS2_FAILURE == status)
500
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
503
axutil_qname_free(element_qname, env);
505
return AXIS2_FAILURE;
511
axutil_qname_free(element_qname, env);
512
element_qname = NULL;
518
* building return element
524
* because elements are ordered this works fine
528
if(current_node != NULL && is_early_node_valid)
530
current_node = axiom_node_get_next_sibling(current_node, env);
533
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
535
current_node = axiom_node_get_next_sibling(current_node, env);
537
if(current_node != NULL)
539
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
540
qname = axiom_element_get_qname(current_element, env, current_node);
544
is_early_node_valid = AXIS2_FALSE;
546
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
550
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
552
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
554
is_early_node_valid = AXIS2_TRUE;
558
text_value = axiom_element_get_text(current_element, env, current_node);
559
if(text_value != NULL)
561
if (!axutil_strcasecmp(text_value , "true"))
563
status = adb_stopNetworkType_set_return(_stopNetworkType, env,
568
status = adb_stopNetworkType_set_return(_stopNetworkType, env,
575
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
576
status = AXIS2_FAILURE;
579
if(AXIS2_FAILURE == status)
581
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
584
axutil_qname_free(element_qname, env);
586
return AXIS2_FAILURE;
592
axutil_qname_free(element_qname, env);
593
element_qname = NULL;
599
* building vlan element
605
* because elements are ordered this works fine
609
if(current_node != NULL && is_early_node_valid)
611
current_node = axiom_node_get_next_sibling(current_node, env);
614
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
616
current_node = axiom_node_get_next_sibling(current_node, env);
618
if(current_node != NULL)
620
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
621
qname = axiom_element_get_qname(current_element, env, current_node);
625
is_early_node_valid = AXIS2_FALSE;
627
element_qname = axutil_qname_create(env, "vlan", "http://eucalyptus.ucsb.edu/", NULL);
631
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
633
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
635
is_early_node_valid = AXIS2_TRUE;
639
text_value = axiom_element_get_text(current_element, env, current_node);
640
if(text_value != NULL)
642
status = adb_stopNetworkType_set_vlan(_stopNetworkType, env,
648
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element vlan");
649
status = AXIS2_FAILURE;
652
if(AXIS2_FAILURE == status)
654
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for vlan ");
657
axutil_qname_free(element_qname, env);
659
return AXIS2_FAILURE;
665
axutil_qname_free(element_qname, env);
666
element_qname = NULL;
672
* building netName element
678
* because elements are ordered this works fine
682
if(current_node != NULL && is_early_node_valid)
684
current_node = axiom_node_get_next_sibling(current_node, env);
687
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
689
current_node = axiom_node_get_next_sibling(current_node, env);
691
if(current_node != NULL)
693
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
694
qname = axiom_element_get_qname(current_element, env, current_node);
698
is_early_node_valid = AXIS2_FALSE;
700
element_qname = axutil_qname_create(env, "netName", "http://eucalyptus.ucsb.edu/", NULL);
704
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
706
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
708
is_early_node_valid = AXIS2_TRUE;
712
text_value = axiom_element_get_text(current_element, env, current_node);
713
if(text_value != NULL)
715
status = adb_stopNetworkType_set_netName(_stopNetworkType, env,
722
* axis2_qname_t *qname = NULL;
723
* axiom_attribute_t *the_attri = NULL;
725
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
726
* the_attri = axiom_element_get_attribute(current_element, env, qname);
728
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
730
axiom_attribute_t *the_attri = NULL;
731
axis2_char_t *attrib_text = NULL;
732
axutil_hash_t *attribute_hash = NULL;
734
attribute_hash = axiom_element_get_all_attributes(current_element, env);
739
axutil_hash_index_t *hi;
743
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
745
axutil_hash_this(hi, &key, NULL, &val);
747
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
749
the_attri = (axiom_attribute_t*)val;
757
attrib_text = axiom_attribute_get_value(the_attri, env);
761
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
762
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
765
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
767
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element netName");
768
status = AXIS2_FAILURE;
772
/* after all, we found this is a empty string */
773
status = adb_stopNetworkType_set_netName(_stopNetworkType, env,
778
if(AXIS2_FAILURE == status)
780
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for netName ");
783
axutil_qname_free(element_qname, env);
785
return AXIS2_FAILURE;
791
axutil_qname_free(element_qname, env);
792
element_qname = NULL;
798
axis2_bool_t AXIS2_CALL
799
adb_stopNetworkType_is_particle()
808
adb_stopNetworkType_declare_parent_namespaces(
809
adb_stopNetworkType_t* _stopNetworkType,
810
const axutil_env_t *env, axiom_element_t *parent_element,
811
axutil_hash_t *namespaces, int *next_ns_index)
814
/* Here this is an empty function, Nothing to declare */
820
axiom_node_t* AXIS2_CALL
821
adb_stopNetworkType_serialize(
822
adb_stopNetworkType_t* _stopNetworkType,
823
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)
827
axis2_char_t *string_to_stream;
830
axiom_node_t *current_node = NULL;
835
axiom_namespace_t *ns1 = NULL;
837
axis2_char_t *qname_uri = NULL;
838
axis2_char_t *qname_prefix = NULL;
839
axis2_char_t *p_prefix = NULL;
840
axis2_bool_t ns_already_defined;
842
axis2_char_t *text_value_1;
843
axis2_char_t *text_value_1_temp;
845
axis2_char_t *text_value_2;
846
axis2_char_t *text_value_2_temp;
848
axis2_char_t *text_value_3;
849
axis2_char_t *text_value_3_temp;
851
axis2_char_t text_value_4[64];
853
axis2_char_t text_value_5[64];
855
axis2_char_t *text_value_6;
856
axis2_char_t *text_value_6_temp;
858
axis2_char_t *start_input_str = NULL;
859
axis2_char_t *end_input_str = NULL;
860
unsigned int start_input_str_len = 0;
861
unsigned int end_input_str_len = 0;
864
axiom_data_source_t *data_source = NULL;
865
axutil_stream_t *stream = NULL;
869
AXIS2_ENV_CHECK(env, NULL);
870
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, NULL);
873
current_node = parent;
874
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
877
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
881
if(!parent_tag_closed)
884
string_to_stream = ">";
885
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
890
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
892
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
893
sprintf(p_prefix, "n%d", (*next_ns_index)++);
894
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
896
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
897
"http://eucalyptus.ucsb.edu/",
902
if (!_stopNetworkType->is_valid_correlationId)
905
/* no need to complain for minoccurs=0 element */
911
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
912
(4 + axutil_strlen(p_prefix) +
913
axutil_strlen("correlationId")));
915
/* axutil_strlen("<:>") + 1 = 4 */
916
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
917
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
918
/* axutil_strlen("</:>") + 1 = 5 */
926
* parsing correlationId element
931
sprintf(start_input_str, "<%s%scorrelationId>",
932
p_prefix?p_prefix:"",
933
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
935
start_input_str_len = axutil_strlen(start_input_str);
936
sprintf(end_input_str, "</%s%scorrelationId>",
937
p_prefix?p_prefix:"",
938
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
939
end_input_str_len = axutil_strlen(end_input_str);
941
text_value_1 = _stopNetworkType->property_correlationId;
943
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
946
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
947
if (text_value_1_temp)
949
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
950
AXIS2_FREE(env->allocator, text_value_1_temp);
954
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
957
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
960
AXIS2_FREE(env->allocator,start_input_str);
961
AXIS2_FREE(env->allocator,end_input_str);
965
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
967
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
968
sprintf(p_prefix, "n%d", (*next_ns_index)++);
969
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
971
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
972
"http://eucalyptus.ucsb.edu/",
977
if (!_stopNetworkType->is_valid_userId)
980
/* no need to complain for minoccurs=0 element */
986
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
987
(4 + axutil_strlen(p_prefix) +
988
axutil_strlen("userId")));
990
/* axutil_strlen("<:>") + 1 = 4 */
991
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
992
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
993
/* axutil_strlen("</:>") + 1 = 5 */
1001
* parsing userId element
1006
sprintf(start_input_str, "<%s%suserId>",
1007
p_prefix?p_prefix:"",
1008
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1010
start_input_str_len = axutil_strlen(start_input_str);
1011
sprintf(end_input_str, "</%s%suserId>",
1012
p_prefix?p_prefix:"",
1013
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1014
end_input_str_len = axutil_strlen(end_input_str);
1016
text_value_2 = _stopNetworkType->property_userId;
1018
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1021
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1022
if (text_value_2_temp)
1024
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
1025
AXIS2_FREE(env->allocator, text_value_2_temp);
1029
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1032
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1035
AXIS2_FREE(env->allocator,start_input_str);
1036
AXIS2_FREE(env->allocator,end_input_str);
1040
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1042
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1043
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1044
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1046
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1047
"http://eucalyptus.ucsb.edu/",
1052
if (!_stopNetworkType->is_valid_statusMessage)
1055
/* no need to complain for minoccurs=0 element */
1061
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1062
(4 + axutil_strlen(p_prefix) +
1063
axutil_strlen("statusMessage")));
1065
/* axutil_strlen("<:>") + 1 = 4 */
1066
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1067
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1068
/* axutil_strlen("</:>") + 1 = 5 */
1076
* parsing statusMessage element
1081
sprintf(start_input_str, "<%s%sstatusMessage>",
1082
p_prefix?p_prefix:"",
1083
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1085
start_input_str_len = axutil_strlen(start_input_str);
1086
sprintf(end_input_str, "</%s%sstatusMessage>",
1087
p_prefix?p_prefix:"",
1088
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1089
end_input_str_len = axutil_strlen(end_input_str);
1091
text_value_3 = _stopNetworkType->property_statusMessage;
1093
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1096
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1097
if (text_value_3_temp)
1099
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1100
AXIS2_FREE(env->allocator, text_value_3_temp);
1104
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1107
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1110
AXIS2_FREE(env->allocator,start_input_str);
1111
AXIS2_FREE(env->allocator,end_input_str);
1115
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1117
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1118
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1119
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1121
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1122
"http://eucalyptus.ucsb.edu/",
1127
if (!_stopNetworkType->is_valid_return)
1130
/* no need to complain for minoccurs=0 element */
1136
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1137
(4 + axutil_strlen(p_prefix) +
1138
axutil_strlen("return")));
1140
/* axutil_strlen("<:>") + 1 = 4 */
1141
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1142
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1143
/* axutil_strlen("</:>") + 1 = 5 */
1151
* parsing return element
1156
sprintf(start_input_str, "<%s%sreturn>",
1157
p_prefix?p_prefix:"",
1158
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1160
start_input_str_len = axutil_strlen(start_input_str);
1161
sprintf(end_input_str, "</%s%sreturn>",
1162
p_prefix?p_prefix:"",
1163
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1164
end_input_str_len = axutil_strlen(end_input_str);
1166
strcpy(text_value_4, (_stopNetworkType->property_return)?"true":"false");
1168
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1170
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1172
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1175
AXIS2_FREE(env->allocator,start_input_str);
1176
AXIS2_FREE(env->allocator,end_input_str);
1180
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1182
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1183
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1184
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1186
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1187
"http://eucalyptus.ucsb.edu/",
1192
if (!_stopNetworkType->is_valid_vlan)
1195
/* no need to complain for minoccurs=0 element */
1201
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1202
(4 + axutil_strlen(p_prefix) +
1203
axutil_strlen("vlan")));
1205
/* axutil_strlen("<:>") + 1 = 4 */
1206
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1207
(5 + axutil_strlen(p_prefix) + axutil_strlen("vlan")));
1208
/* axutil_strlen("</:>") + 1 = 5 */
1216
* parsing vlan element
1221
sprintf(start_input_str, "<%s%svlan>",
1222
p_prefix?p_prefix:"",
1223
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1225
start_input_str_len = axutil_strlen(start_input_str);
1226
sprintf(end_input_str, "</%s%svlan>",
1227
p_prefix?p_prefix:"",
1228
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1229
end_input_str_len = axutil_strlen(end_input_str);
1231
sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _stopNetworkType->property_vlan);
1233
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1235
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1237
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1240
AXIS2_FREE(env->allocator,start_input_str);
1241
AXIS2_FREE(env->allocator,end_input_str);
1245
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1247
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1248
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1249
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1251
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1252
"http://eucalyptus.ucsb.edu/",
1257
if (!_stopNetworkType->is_valid_netName)
1260
/* no need to complain for minoccurs=0 element */
1266
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1267
(4 + axutil_strlen(p_prefix) +
1268
axutil_strlen("netName")));
1270
/* axutil_strlen("<:>") + 1 = 4 */
1271
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1272
(5 + axutil_strlen(p_prefix) + axutil_strlen("netName")));
1273
/* axutil_strlen("</:>") + 1 = 5 */
1281
* parsing netName element
1286
sprintf(start_input_str, "<%s%snetName>",
1287
p_prefix?p_prefix:"",
1288
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1290
start_input_str_len = axutil_strlen(start_input_str);
1291
sprintf(end_input_str, "</%s%snetName>",
1292
p_prefix?p_prefix:"",
1293
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1294
end_input_str_len = axutil_strlen(end_input_str);
1296
text_value_6 = _stopNetworkType->property_netName;
1298
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1301
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1302
if (text_value_6_temp)
1304
axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
1305
AXIS2_FREE(env->allocator, text_value_6_temp);
1309
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1312
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1315
AXIS2_FREE(env->allocator,start_input_str);
1316
AXIS2_FREE(env->allocator,end_input_str);
1328
* getter for correlationId.
1330
axis2_char_t* AXIS2_CALL
1331
adb_stopNetworkType_get_correlationId(
1332
adb_stopNetworkType_t* _stopNetworkType,
1333
const axutil_env_t *env)
1336
AXIS2_ENV_CHECK(env, NULL);
1337
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, NULL);
1340
return _stopNetworkType->property_correlationId;
1344
* setter for correlationId
1346
axis2_status_t AXIS2_CALL
1347
adb_stopNetworkType_set_correlationId(
1348
adb_stopNetworkType_t* _stopNetworkType,
1349
const axutil_env_t *env,
1350
const axis2_char_t* arg_correlationId)
1354
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1355
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1357
if(_stopNetworkType->is_valid_correlationId &&
1358
arg_correlationId == _stopNetworkType->property_correlationId)
1361
return AXIS2_SUCCESS;
1364
adb_stopNetworkType_reset_correlationId(_stopNetworkType, env);
1367
if(NULL == arg_correlationId)
1369
/* We are already done */
1370
return AXIS2_SUCCESS;
1372
_stopNetworkType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1373
if(NULL == _stopNetworkType->property_correlationId)
1375
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1376
return AXIS2_FAILURE;
1378
_stopNetworkType->is_valid_correlationId = AXIS2_TRUE;
1380
return AXIS2_SUCCESS;
1386
* resetter for correlationId
1388
axis2_status_t AXIS2_CALL
1389
adb_stopNetworkType_reset_correlationId(
1390
adb_stopNetworkType_t* _stopNetworkType,
1391
const axutil_env_t *env)
1395
void *element = NULL;
1397
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1398
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1404
if(_stopNetworkType->property_correlationId != NULL)
1408
AXIS2_FREE(env-> allocator, _stopNetworkType->property_correlationId);
1409
_stopNetworkType->property_correlationId = NULL;
1414
_stopNetworkType->is_valid_correlationId = AXIS2_FALSE;
1415
return AXIS2_SUCCESS;
1419
* Check whether correlationId is nill
1421
axis2_bool_t AXIS2_CALL
1422
adb_stopNetworkType_is_correlationId_nil(
1423
adb_stopNetworkType_t* _stopNetworkType,
1424
const axutil_env_t *env)
1426
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1427
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_TRUE);
1429
return !_stopNetworkType->is_valid_correlationId;
1433
* Set correlationId to nill (currently the same as reset)
1435
axis2_status_t AXIS2_CALL
1436
adb_stopNetworkType_set_correlationId_nil(
1437
adb_stopNetworkType_t* _stopNetworkType,
1438
const axutil_env_t *env)
1440
return adb_stopNetworkType_reset_correlationId(_stopNetworkType, env);
1446
* getter for userId.
1448
axis2_char_t* AXIS2_CALL
1449
adb_stopNetworkType_get_userId(
1450
adb_stopNetworkType_t* _stopNetworkType,
1451
const axutil_env_t *env)
1454
AXIS2_ENV_CHECK(env, NULL);
1455
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, NULL);
1458
return _stopNetworkType->property_userId;
1464
axis2_status_t AXIS2_CALL
1465
adb_stopNetworkType_set_userId(
1466
adb_stopNetworkType_t* _stopNetworkType,
1467
const axutil_env_t *env,
1468
const axis2_char_t* arg_userId)
1472
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1473
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1475
if(_stopNetworkType->is_valid_userId &&
1476
arg_userId == _stopNetworkType->property_userId)
1479
return AXIS2_SUCCESS;
1482
adb_stopNetworkType_reset_userId(_stopNetworkType, env);
1485
if(NULL == arg_userId)
1487
/* We are already done */
1488
return AXIS2_SUCCESS;
1490
_stopNetworkType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1491
if(NULL == _stopNetworkType->property_userId)
1493
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1494
return AXIS2_FAILURE;
1496
_stopNetworkType->is_valid_userId = AXIS2_TRUE;
1498
return AXIS2_SUCCESS;
1504
* resetter for userId
1506
axis2_status_t AXIS2_CALL
1507
adb_stopNetworkType_reset_userId(
1508
adb_stopNetworkType_t* _stopNetworkType,
1509
const axutil_env_t *env)
1513
void *element = NULL;
1515
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1516
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1522
if(_stopNetworkType->property_userId != NULL)
1526
AXIS2_FREE(env-> allocator, _stopNetworkType->property_userId);
1527
_stopNetworkType->property_userId = NULL;
1532
_stopNetworkType->is_valid_userId = AXIS2_FALSE;
1533
return AXIS2_SUCCESS;
1537
* Check whether userId is nill
1539
axis2_bool_t AXIS2_CALL
1540
adb_stopNetworkType_is_userId_nil(
1541
adb_stopNetworkType_t* _stopNetworkType,
1542
const axutil_env_t *env)
1544
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1545
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_TRUE);
1547
return !_stopNetworkType->is_valid_userId;
1551
* Set userId to nill (currently the same as reset)
1553
axis2_status_t AXIS2_CALL
1554
adb_stopNetworkType_set_userId_nil(
1555
adb_stopNetworkType_t* _stopNetworkType,
1556
const axutil_env_t *env)
1558
return adb_stopNetworkType_reset_userId(_stopNetworkType, env);
1564
* getter for statusMessage.
1566
axis2_char_t* AXIS2_CALL
1567
adb_stopNetworkType_get_statusMessage(
1568
adb_stopNetworkType_t* _stopNetworkType,
1569
const axutil_env_t *env)
1572
AXIS2_ENV_CHECK(env, NULL);
1573
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, NULL);
1576
return _stopNetworkType->property_statusMessage;
1580
* setter for statusMessage
1582
axis2_status_t AXIS2_CALL
1583
adb_stopNetworkType_set_statusMessage(
1584
adb_stopNetworkType_t* _stopNetworkType,
1585
const axutil_env_t *env,
1586
const axis2_char_t* arg_statusMessage)
1590
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1591
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1593
if(_stopNetworkType->is_valid_statusMessage &&
1594
arg_statusMessage == _stopNetworkType->property_statusMessage)
1597
return AXIS2_SUCCESS;
1600
adb_stopNetworkType_reset_statusMessage(_stopNetworkType, env);
1603
if(NULL == arg_statusMessage)
1605
/* We are already done */
1606
return AXIS2_SUCCESS;
1608
_stopNetworkType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1609
if(NULL == _stopNetworkType->property_statusMessage)
1611
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1612
return AXIS2_FAILURE;
1614
_stopNetworkType->is_valid_statusMessage = AXIS2_TRUE;
1616
return AXIS2_SUCCESS;
1622
* resetter for statusMessage
1624
axis2_status_t AXIS2_CALL
1625
adb_stopNetworkType_reset_statusMessage(
1626
adb_stopNetworkType_t* _stopNetworkType,
1627
const axutil_env_t *env)
1631
void *element = NULL;
1633
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1634
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1640
if(_stopNetworkType->property_statusMessage != NULL)
1644
AXIS2_FREE(env-> allocator, _stopNetworkType->property_statusMessage);
1645
_stopNetworkType->property_statusMessage = NULL;
1650
_stopNetworkType->is_valid_statusMessage = AXIS2_FALSE;
1651
return AXIS2_SUCCESS;
1655
* Check whether statusMessage is nill
1657
axis2_bool_t AXIS2_CALL
1658
adb_stopNetworkType_is_statusMessage_nil(
1659
adb_stopNetworkType_t* _stopNetworkType,
1660
const axutil_env_t *env)
1662
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1663
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_TRUE);
1665
return !_stopNetworkType->is_valid_statusMessage;
1669
* Set statusMessage to nill (currently the same as reset)
1671
axis2_status_t AXIS2_CALL
1672
adb_stopNetworkType_set_statusMessage_nil(
1673
adb_stopNetworkType_t* _stopNetworkType,
1674
const axutil_env_t *env)
1676
return adb_stopNetworkType_reset_statusMessage(_stopNetworkType, env);
1682
* getter for return.
1684
axis2_bool_t AXIS2_CALL
1685
adb_stopNetworkType_get_return(
1686
adb_stopNetworkType_t* _stopNetworkType,
1687
const axutil_env_t *env)
1690
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1691
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, (axis2_bool_t)0);
1694
return _stopNetworkType->property_return;
1700
axis2_status_t AXIS2_CALL
1701
adb_stopNetworkType_set_return(
1702
adb_stopNetworkType_t* _stopNetworkType,
1703
const axutil_env_t *env,
1704
axis2_bool_t arg_return)
1708
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1709
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1711
if(_stopNetworkType->is_valid_return &&
1712
arg_return == _stopNetworkType->property_return)
1715
return AXIS2_SUCCESS;
1718
adb_stopNetworkType_reset_return(_stopNetworkType, env);
1720
_stopNetworkType->property_return = arg_return;
1721
_stopNetworkType->is_valid_return = AXIS2_TRUE;
1723
return AXIS2_SUCCESS;
1729
* resetter for return
1731
axis2_status_t AXIS2_CALL
1732
adb_stopNetworkType_reset_return(
1733
adb_stopNetworkType_t* _stopNetworkType,
1734
const axutil_env_t *env)
1738
void *element = NULL;
1740
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1741
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1744
_stopNetworkType->is_valid_return = AXIS2_FALSE;
1745
return AXIS2_SUCCESS;
1749
* Check whether return is nill
1751
axis2_bool_t AXIS2_CALL
1752
adb_stopNetworkType_is_return_nil(
1753
adb_stopNetworkType_t* _stopNetworkType,
1754
const axutil_env_t *env)
1756
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1757
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_TRUE);
1759
return !_stopNetworkType->is_valid_return;
1763
* Set return to nill (currently the same as reset)
1765
axis2_status_t AXIS2_CALL
1766
adb_stopNetworkType_set_return_nil(
1767
adb_stopNetworkType_t* _stopNetworkType,
1768
const axutil_env_t *env)
1770
return adb_stopNetworkType_reset_return(_stopNetworkType, env);
1779
adb_stopNetworkType_get_vlan(
1780
adb_stopNetworkType_t* _stopNetworkType,
1781
const axutil_env_t *env)
1784
AXIS2_ENV_CHECK(env, (int)0);
1785
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, (int)0);
1788
return _stopNetworkType->property_vlan;
1794
axis2_status_t AXIS2_CALL
1795
adb_stopNetworkType_set_vlan(
1796
adb_stopNetworkType_t* _stopNetworkType,
1797
const axutil_env_t *env,
1802
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1803
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1805
if(_stopNetworkType->is_valid_vlan &&
1806
arg_vlan == _stopNetworkType->property_vlan)
1809
return AXIS2_SUCCESS;
1812
adb_stopNetworkType_reset_vlan(_stopNetworkType, env);
1814
_stopNetworkType->property_vlan = arg_vlan;
1815
_stopNetworkType->is_valid_vlan = AXIS2_TRUE;
1817
return AXIS2_SUCCESS;
1825
axis2_status_t AXIS2_CALL
1826
adb_stopNetworkType_reset_vlan(
1827
adb_stopNetworkType_t* _stopNetworkType,
1828
const axutil_env_t *env)
1832
void *element = NULL;
1834
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1835
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1838
_stopNetworkType->is_valid_vlan = AXIS2_FALSE;
1839
return AXIS2_SUCCESS;
1843
* Check whether vlan is nill
1845
axis2_bool_t AXIS2_CALL
1846
adb_stopNetworkType_is_vlan_nil(
1847
adb_stopNetworkType_t* _stopNetworkType,
1848
const axutil_env_t *env)
1850
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1851
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_TRUE);
1853
return !_stopNetworkType->is_valid_vlan;
1857
* Set vlan to nill (currently the same as reset)
1859
axis2_status_t AXIS2_CALL
1860
adb_stopNetworkType_set_vlan_nil(
1861
adb_stopNetworkType_t* _stopNetworkType,
1862
const axutil_env_t *env)
1864
return adb_stopNetworkType_reset_vlan(_stopNetworkType, env);
1870
* getter for netName.
1872
axis2_char_t* AXIS2_CALL
1873
adb_stopNetworkType_get_netName(
1874
adb_stopNetworkType_t* _stopNetworkType,
1875
const axutil_env_t *env)
1878
AXIS2_ENV_CHECK(env, NULL);
1879
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, NULL);
1882
return _stopNetworkType->property_netName;
1886
* setter for netName
1888
axis2_status_t AXIS2_CALL
1889
adb_stopNetworkType_set_netName(
1890
adb_stopNetworkType_t* _stopNetworkType,
1891
const axutil_env_t *env,
1892
const axis2_char_t* arg_netName)
1896
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1897
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1899
if(_stopNetworkType->is_valid_netName &&
1900
arg_netName == _stopNetworkType->property_netName)
1903
return AXIS2_SUCCESS;
1906
adb_stopNetworkType_reset_netName(_stopNetworkType, env);
1909
if(NULL == arg_netName)
1911
/* We are already done */
1912
return AXIS2_SUCCESS;
1914
_stopNetworkType->property_netName = (axis2_char_t *)axutil_strdup(env, arg_netName);
1915
if(NULL == _stopNetworkType->property_netName)
1917
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for netName");
1918
return AXIS2_FAILURE;
1920
_stopNetworkType->is_valid_netName = AXIS2_TRUE;
1922
return AXIS2_SUCCESS;
1928
* resetter for netName
1930
axis2_status_t AXIS2_CALL
1931
adb_stopNetworkType_reset_netName(
1932
adb_stopNetworkType_t* _stopNetworkType,
1933
const axutil_env_t *env)
1937
void *element = NULL;
1939
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1940
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_FAILURE);
1946
if(_stopNetworkType->property_netName != NULL)
1950
AXIS2_FREE(env-> allocator, _stopNetworkType->property_netName);
1951
_stopNetworkType->property_netName = NULL;
1956
_stopNetworkType->is_valid_netName = AXIS2_FALSE;
1957
return AXIS2_SUCCESS;
1961
* Check whether netName is nill
1963
axis2_bool_t AXIS2_CALL
1964
adb_stopNetworkType_is_netName_nil(
1965
adb_stopNetworkType_t* _stopNetworkType,
1966
const axutil_env_t *env)
1968
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1969
AXIS2_PARAM_CHECK(env->error, _stopNetworkType, AXIS2_TRUE);
1971
return !_stopNetworkType->is_valid_netName;
1975
* Set netName to nill (currently the same as reset)
1977
axis2_status_t AXIS2_CALL
1978
adb_stopNetworkType_set_netName_nil(
1979
adb_stopNetworkType_t* _stopNetworkType,
1980
const axutil_env_t *env)
1982
return adb_stopNetworkType_reset_netName(_stopNetworkType, env);