4
* adb_ncPowerDownType.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_ncPowerDownType.h"
13
* This type was generated from the piece of schema that had
14
* name = ncPowerDownType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_ncPowerDownType
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;
51
/************************* Private Function prototypes ********************************/
54
axis2_status_t AXIS2_CALL
55
adb_ncPowerDownType_set_correlationId_nil(
56
adb_ncPowerDownType_t* _ncPowerDownType,
57
const axutil_env_t *env);
60
axis2_status_t AXIS2_CALL
61
adb_ncPowerDownType_set_userId_nil(
62
adb_ncPowerDownType_t* _ncPowerDownType,
63
const axutil_env_t *env);
66
axis2_status_t AXIS2_CALL
67
adb_ncPowerDownType_set_return_nil(
68
adb_ncPowerDownType_t* _ncPowerDownType,
69
const axutil_env_t *env);
73
/************************* Function Implmentations ********************************/
74
adb_ncPowerDownType_t* AXIS2_CALL
75
adb_ncPowerDownType_create(
76
const axutil_env_t *env)
78
adb_ncPowerDownType_t *_ncPowerDownType = NULL;
80
AXIS2_ENV_CHECK(env, NULL);
82
_ncPowerDownType = (adb_ncPowerDownType_t *) AXIS2_MALLOC(env->
83
allocator, sizeof(adb_ncPowerDownType_t));
85
if(NULL == _ncPowerDownType)
87
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
91
memset(_ncPowerDownType, 0, sizeof(adb_ncPowerDownType_t));
93
_ncPowerDownType->property_correlationId = NULL;
94
_ncPowerDownType->is_valid_correlationId = AXIS2_FALSE;
95
_ncPowerDownType->property_userId = NULL;
96
_ncPowerDownType->is_valid_userId = AXIS2_FALSE;
97
_ncPowerDownType->is_valid_return = AXIS2_FALSE;
98
_ncPowerDownType->is_valid_statusMessage = AXIS2_FALSE;
101
return _ncPowerDownType;
104
axis2_status_t AXIS2_CALL
105
adb_ncPowerDownType_free (
106
adb_ncPowerDownType_t* _ncPowerDownType,
107
const axutil_env_t *env)
111
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
112
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
114
adb_ncPowerDownType_reset_correlationId(_ncPowerDownType, env);
115
adb_ncPowerDownType_reset_userId(_ncPowerDownType, env);
116
adb_ncPowerDownType_reset_return(_ncPowerDownType, env);
117
adb_ncPowerDownType_reset_statusMessage(_ncPowerDownType, env);
122
AXIS2_FREE(env->allocator, _ncPowerDownType);
123
_ncPowerDownType = NULL;
125
return AXIS2_SUCCESS;
131
axis2_status_t AXIS2_CALL
132
adb_ncPowerDownType_deserialize(
133
adb_ncPowerDownType_t* _ncPowerDownType,
134
const axutil_env_t *env,
135
axiom_node_t **dp_parent,
136
axis2_bool_t *dp_is_early_node_valid,
137
axis2_bool_t dont_care_minoccurs)
139
axiom_node_t *parent = *dp_parent;
141
axis2_status_t status = AXIS2_SUCCESS;
143
axis2_char_t* text_value = NULL;
144
axutil_qname_t *qname = NULL;
146
axutil_qname_t *element_qname = NULL;
148
axiom_node_t *first_node = NULL;
149
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
150
axiom_node_t *current_node = NULL;
151
axiom_element_t *current_element = NULL;
153
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
154
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
158
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
160
parent = axiom_node_get_next_sibling(parent, env);
164
/* This should be checked before everything */
165
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
166
"Failed in building adb object for ncPowerDownType : "
167
"NULL elemenet can not be passed to deserialize");
168
return AXIS2_FAILURE;
172
first_node = axiom_node_get_first_child(parent, env);
178
* building correlationId element
183
current_node = first_node;
184
is_early_node_valid = AXIS2_FALSE;
187
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
189
current_node = axiom_node_get_next_sibling(current_node, env);
191
if(current_node != NULL)
193
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
194
qname = axiom_element_get_qname(current_element, env, current_node);
197
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
201
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
203
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
205
is_early_node_valid = AXIS2_TRUE;
209
text_value = axiom_element_get_text(current_element, env, current_node);
210
if(text_value != NULL)
212
status = adb_ncPowerDownType_set_correlationId(_ncPowerDownType, env,
219
* axis2_qname_t *qname = NULL;
220
* axiom_attribute_t *the_attri = NULL;
222
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
223
* the_attri = axiom_element_get_attribute(current_element, env, qname);
225
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
227
axiom_attribute_t *the_attri = NULL;
228
axis2_char_t *attrib_text = NULL;
229
axutil_hash_t *attribute_hash = NULL;
231
attribute_hash = axiom_element_get_all_attributes(current_element, env);
236
axutil_hash_index_t *hi;
240
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
242
axutil_hash_this(hi, &key, NULL, &val);
244
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
246
the_attri = (axiom_attribute_t*)val;
254
attrib_text = axiom_attribute_get_value(the_attri, env);
258
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
259
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
262
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
264
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
265
status = AXIS2_FAILURE;
269
/* after all, we found this is a empty string */
270
status = adb_ncPowerDownType_set_correlationId(_ncPowerDownType, env,
275
if(AXIS2_FAILURE == status)
277
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
280
axutil_qname_free(element_qname, env);
282
return AXIS2_FAILURE;
288
axutil_qname_free(element_qname, env);
289
element_qname = NULL;
295
* building userId element
301
* because elements are ordered this works fine
305
if(current_node != NULL && is_early_node_valid)
307
current_node = axiom_node_get_next_sibling(current_node, env);
310
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
312
current_node = axiom_node_get_next_sibling(current_node, env);
314
if(current_node != NULL)
316
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
317
qname = axiom_element_get_qname(current_element, env, current_node);
321
is_early_node_valid = AXIS2_FALSE;
323
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
327
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
329
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
331
is_early_node_valid = AXIS2_TRUE;
335
text_value = axiom_element_get_text(current_element, env, current_node);
336
if(text_value != NULL)
338
status = adb_ncPowerDownType_set_userId(_ncPowerDownType, env,
345
* axis2_qname_t *qname = NULL;
346
* axiom_attribute_t *the_attri = NULL;
348
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
349
* the_attri = axiom_element_get_attribute(current_element, env, qname);
351
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
353
axiom_attribute_t *the_attri = NULL;
354
axis2_char_t *attrib_text = NULL;
355
axutil_hash_t *attribute_hash = NULL;
357
attribute_hash = axiom_element_get_all_attributes(current_element, env);
362
axutil_hash_index_t *hi;
366
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
368
axutil_hash_this(hi, &key, NULL, &val);
370
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
372
the_attri = (axiom_attribute_t*)val;
380
attrib_text = axiom_attribute_get_value(the_attri, env);
384
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
385
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
388
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
390
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
391
status = AXIS2_FAILURE;
395
/* after all, we found this is a empty string */
396
status = adb_ncPowerDownType_set_userId(_ncPowerDownType, env,
401
if(AXIS2_FAILURE == status)
403
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
406
axutil_qname_free(element_qname, env);
408
return AXIS2_FAILURE;
414
axutil_qname_free(element_qname, env);
415
element_qname = NULL;
421
* building return element
427
* because elements are ordered this works fine
431
if(current_node != NULL && is_early_node_valid)
433
current_node = axiom_node_get_next_sibling(current_node, env);
436
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
438
current_node = axiom_node_get_next_sibling(current_node, env);
440
if(current_node != NULL)
442
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
443
qname = axiom_element_get_qname(current_element, env, current_node);
447
is_early_node_valid = AXIS2_FALSE;
449
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
453
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
455
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
457
is_early_node_valid = AXIS2_TRUE;
461
text_value = axiom_element_get_text(current_element, env, current_node);
462
if(text_value != NULL)
464
if (!axutil_strcasecmp(text_value , "true"))
466
status = adb_ncPowerDownType_set_return(_ncPowerDownType, env,
471
status = adb_ncPowerDownType_set_return(_ncPowerDownType, env,
478
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
479
status = AXIS2_FAILURE;
482
if(AXIS2_FAILURE == status)
484
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
487
axutil_qname_free(element_qname, env);
489
return AXIS2_FAILURE;
495
axutil_qname_free(element_qname, env);
496
element_qname = NULL;
502
* building statusMessage element
508
* because elements are ordered this works fine
512
if(current_node != NULL && is_early_node_valid)
514
current_node = axiom_node_get_next_sibling(current_node, env);
517
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
519
current_node = axiom_node_get_next_sibling(current_node, env);
521
if(current_node != NULL)
523
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
524
qname = axiom_element_get_qname(current_element, env, current_node);
528
is_early_node_valid = AXIS2_FALSE;
530
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
534
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
536
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
538
is_early_node_valid = AXIS2_TRUE;
542
text_value = axiom_element_get_text(current_element, env, current_node);
543
if(text_value != NULL)
545
status = adb_ncPowerDownType_set_statusMessage(_ncPowerDownType, env,
549
if(AXIS2_FAILURE == status)
551
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
554
axutil_qname_free(element_qname, env);
556
return AXIS2_FAILURE;
562
axutil_qname_free(element_qname, env);
563
element_qname = NULL;
569
axis2_bool_t AXIS2_CALL
570
adb_ncPowerDownType_is_particle()
579
adb_ncPowerDownType_declare_parent_namespaces(
580
adb_ncPowerDownType_t* _ncPowerDownType,
581
const axutil_env_t *env, axiom_element_t *parent_element,
582
axutil_hash_t *namespaces, int *next_ns_index)
585
/* Here this is an empty function, Nothing to declare */
591
axiom_node_t* AXIS2_CALL
592
adb_ncPowerDownType_serialize(
593
adb_ncPowerDownType_t* _ncPowerDownType,
594
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)
598
axis2_char_t *string_to_stream;
601
axiom_node_t *current_node = NULL;
606
axiom_namespace_t *ns1 = NULL;
608
axis2_char_t *qname_uri = NULL;
609
axis2_char_t *qname_prefix = NULL;
610
axis2_char_t *p_prefix = NULL;
611
axis2_bool_t ns_already_defined;
613
axis2_char_t *text_value_1;
614
axis2_char_t *text_value_1_temp;
616
axis2_char_t *text_value_2;
617
axis2_char_t *text_value_2_temp;
619
axis2_char_t text_value_3[64];
621
axis2_char_t text_value_4[64];
623
axis2_char_t *start_input_str = NULL;
624
axis2_char_t *end_input_str = NULL;
625
unsigned int start_input_str_len = 0;
626
unsigned int end_input_str_len = 0;
629
axiom_data_source_t *data_source = NULL;
630
axutil_stream_t *stream = NULL;
634
AXIS2_ENV_CHECK(env, NULL);
635
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, NULL);
638
current_node = parent;
639
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
642
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
646
if(!parent_tag_closed)
649
string_to_stream = ">";
650
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
655
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
657
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
658
sprintf(p_prefix, "n%d", (*next_ns_index)++);
659
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
661
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
662
"http://eucalyptus.ucsb.edu/",
667
if (!_ncPowerDownType->is_valid_correlationId)
670
/* no need to complain for minoccurs=0 element */
676
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
677
(4 + axutil_strlen(p_prefix) +
678
axutil_strlen("correlationId")));
680
/* axutil_strlen("<:>") + 1 = 4 */
681
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
682
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
683
/* axutil_strlen("</:>") + 1 = 5 */
691
* parsing correlationId element
696
sprintf(start_input_str, "<%s%scorrelationId>",
697
p_prefix?p_prefix:"",
698
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
700
start_input_str_len = axutil_strlen(start_input_str);
701
sprintf(end_input_str, "</%s%scorrelationId>",
702
p_prefix?p_prefix:"",
703
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
704
end_input_str_len = axutil_strlen(end_input_str);
706
text_value_1 = _ncPowerDownType->property_correlationId;
708
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
711
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
712
if (text_value_1_temp)
714
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
715
AXIS2_FREE(env->allocator, text_value_1_temp);
719
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
722
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
725
AXIS2_FREE(env->allocator,start_input_str);
726
AXIS2_FREE(env->allocator,end_input_str);
730
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
732
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
733
sprintf(p_prefix, "n%d", (*next_ns_index)++);
734
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
736
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
737
"http://eucalyptus.ucsb.edu/",
742
if (!_ncPowerDownType->is_valid_userId)
745
/* no need to complain for minoccurs=0 element */
751
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
752
(4 + axutil_strlen(p_prefix) +
753
axutil_strlen("userId")));
755
/* axutil_strlen("<:>") + 1 = 4 */
756
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
757
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
758
/* axutil_strlen("</:>") + 1 = 5 */
766
* parsing userId element
771
sprintf(start_input_str, "<%s%suserId>",
772
p_prefix?p_prefix:"",
773
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
775
start_input_str_len = axutil_strlen(start_input_str);
776
sprintf(end_input_str, "</%s%suserId>",
777
p_prefix?p_prefix:"",
778
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
779
end_input_str_len = axutil_strlen(end_input_str);
781
text_value_2 = _ncPowerDownType->property_userId;
783
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
786
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
787
if (text_value_2_temp)
789
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
790
AXIS2_FREE(env->allocator, text_value_2_temp);
794
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
797
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
800
AXIS2_FREE(env->allocator,start_input_str);
801
AXIS2_FREE(env->allocator,end_input_str);
805
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
807
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
808
sprintf(p_prefix, "n%d", (*next_ns_index)++);
809
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
811
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
812
"http://eucalyptus.ucsb.edu/",
817
if (!_ncPowerDownType->is_valid_return)
820
/* no need to complain for minoccurs=0 element */
826
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
827
(4 + axutil_strlen(p_prefix) +
828
axutil_strlen("return")));
830
/* axutil_strlen("<:>") + 1 = 4 */
831
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
832
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
833
/* axutil_strlen("</:>") + 1 = 5 */
841
* parsing return element
846
sprintf(start_input_str, "<%s%sreturn>",
847
p_prefix?p_prefix:"",
848
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
850
start_input_str_len = axutil_strlen(start_input_str);
851
sprintf(end_input_str, "</%s%sreturn>",
852
p_prefix?p_prefix:"",
853
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
854
end_input_str_len = axutil_strlen(end_input_str);
856
strcpy(text_value_3, (_ncPowerDownType->property_return)?"true":"false");
858
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
860
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
862
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
865
AXIS2_FREE(env->allocator,start_input_str);
866
AXIS2_FREE(env->allocator,end_input_str);
870
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
872
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
873
sprintf(p_prefix, "n%d", (*next_ns_index)++);
874
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
876
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
877
"http://eucalyptus.ucsb.edu/",
882
if (!_ncPowerDownType->is_valid_statusMessage)
885
/* no need to complain for minoccurs=0 element */
891
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
892
(4 + axutil_strlen(p_prefix) +
893
axutil_strlen("statusMessage")));
895
/* axutil_strlen("<:>") + 1 = 4 */
896
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
897
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
898
/* axutil_strlen("</:>") + 1 = 5 */
906
* parsing statusMessage element
911
sprintf(start_input_str, "<%s%sstatusMessage>",
912
p_prefix?p_prefix:"",
913
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
915
start_input_str_len = axutil_strlen(start_input_str);
916
sprintf(end_input_str, "</%s%sstatusMessage>",
917
p_prefix?p_prefix:"",
918
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
919
end_input_str_len = axutil_strlen(end_input_str);
921
sprintf (text_value_4, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncPowerDownType->property_statusMessage);
923
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
925
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
927
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
930
AXIS2_FREE(env->allocator,start_input_str);
931
AXIS2_FREE(env->allocator,end_input_str);
943
* getter for correlationId.
945
axis2_char_t* AXIS2_CALL
946
adb_ncPowerDownType_get_correlationId(
947
adb_ncPowerDownType_t* _ncPowerDownType,
948
const axutil_env_t *env)
951
AXIS2_ENV_CHECK(env, NULL);
952
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, NULL);
955
return _ncPowerDownType->property_correlationId;
959
* setter for correlationId
961
axis2_status_t AXIS2_CALL
962
adb_ncPowerDownType_set_correlationId(
963
adb_ncPowerDownType_t* _ncPowerDownType,
964
const axutil_env_t *env,
965
const axis2_char_t* arg_correlationId)
969
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
970
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
972
if(_ncPowerDownType->is_valid_correlationId &&
973
arg_correlationId == _ncPowerDownType->property_correlationId)
976
return AXIS2_SUCCESS;
979
adb_ncPowerDownType_reset_correlationId(_ncPowerDownType, env);
982
if(NULL == arg_correlationId)
984
/* We are already done */
985
return AXIS2_SUCCESS;
987
_ncPowerDownType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
988
if(NULL == _ncPowerDownType->property_correlationId)
990
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
991
return AXIS2_FAILURE;
993
_ncPowerDownType->is_valid_correlationId = AXIS2_TRUE;
995
return AXIS2_SUCCESS;
1001
* resetter for correlationId
1003
axis2_status_t AXIS2_CALL
1004
adb_ncPowerDownType_reset_correlationId(
1005
adb_ncPowerDownType_t* _ncPowerDownType,
1006
const axutil_env_t *env)
1010
void *element = NULL;
1012
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1013
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
1019
if(_ncPowerDownType->property_correlationId != NULL)
1023
AXIS2_FREE(env-> allocator, _ncPowerDownType->property_correlationId);
1024
_ncPowerDownType->property_correlationId = NULL;
1029
_ncPowerDownType->is_valid_correlationId = AXIS2_FALSE;
1030
return AXIS2_SUCCESS;
1034
* Check whether correlationId is nill
1036
axis2_bool_t AXIS2_CALL
1037
adb_ncPowerDownType_is_correlationId_nil(
1038
adb_ncPowerDownType_t* _ncPowerDownType,
1039
const axutil_env_t *env)
1041
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1042
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_TRUE);
1044
return !_ncPowerDownType->is_valid_correlationId;
1048
* Set correlationId to nill (currently the same as reset)
1050
axis2_status_t AXIS2_CALL
1051
adb_ncPowerDownType_set_correlationId_nil(
1052
adb_ncPowerDownType_t* _ncPowerDownType,
1053
const axutil_env_t *env)
1055
return adb_ncPowerDownType_reset_correlationId(_ncPowerDownType, env);
1061
* getter for userId.
1063
axis2_char_t* AXIS2_CALL
1064
adb_ncPowerDownType_get_userId(
1065
adb_ncPowerDownType_t* _ncPowerDownType,
1066
const axutil_env_t *env)
1069
AXIS2_ENV_CHECK(env, NULL);
1070
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, NULL);
1073
return _ncPowerDownType->property_userId;
1079
axis2_status_t AXIS2_CALL
1080
adb_ncPowerDownType_set_userId(
1081
adb_ncPowerDownType_t* _ncPowerDownType,
1082
const axutil_env_t *env,
1083
const axis2_char_t* arg_userId)
1087
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1088
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
1090
if(_ncPowerDownType->is_valid_userId &&
1091
arg_userId == _ncPowerDownType->property_userId)
1094
return AXIS2_SUCCESS;
1097
adb_ncPowerDownType_reset_userId(_ncPowerDownType, env);
1100
if(NULL == arg_userId)
1102
/* We are already done */
1103
return AXIS2_SUCCESS;
1105
_ncPowerDownType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1106
if(NULL == _ncPowerDownType->property_userId)
1108
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1109
return AXIS2_FAILURE;
1111
_ncPowerDownType->is_valid_userId = AXIS2_TRUE;
1113
return AXIS2_SUCCESS;
1119
* resetter for userId
1121
axis2_status_t AXIS2_CALL
1122
adb_ncPowerDownType_reset_userId(
1123
adb_ncPowerDownType_t* _ncPowerDownType,
1124
const axutil_env_t *env)
1128
void *element = NULL;
1130
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1131
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
1137
if(_ncPowerDownType->property_userId != NULL)
1141
AXIS2_FREE(env-> allocator, _ncPowerDownType->property_userId);
1142
_ncPowerDownType->property_userId = NULL;
1147
_ncPowerDownType->is_valid_userId = AXIS2_FALSE;
1148
return AXIS2_SUCCESS;
1152
* Check whether userId is nill
1154
axis2_bool_t AXIS2_CALL
1155
adb_ncPowerDownType_is_userId_nil(
1156
adb_ncPowerDownType_t* _ncPowerDownType,
1157
const axutil_env_t *env)
1159
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1160
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_TRUE);
1162
return !_ncPowerDownType->is_valid_userId;
1166
* Set userId to nill (currently the same as reset)
1168
axis2_status_t AXIS2_CALL
1169
adb_ncPowerDownType_set_userId_nil(
1170
adb_ncPowerDownType_t* _ncPowerDownType,
1171
const axutil_env_t *env)
1173
return adb_ncPowerDownType_reset_userId(_ncPowerDownType, env);
1179
* getter for return.
1181
axis2_bool_t AXIS2_CALL
1182
adb_ncPowerDownType_get_return(
1183
adb_ncPowerDownType_t* _ncPowerDownType,
1184
const axutil_env_t *env)
1187
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1188
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, (axis2_bool_t)0);
1191
return _ncPowerDownType->property_return;
1197
axis2_status_t AXIS2_CALL
1198
adb_ncPowerDownType_set_return(
1199
adb_ncPowerDownType_t* _ncPowerDownType,
1200
const axutil_env_t *env,
1201
axis2_bool_t arg_return)
1205
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1206
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
1208
if(_ncPowerDownType->is_valid_return &&
1209
arg_return == _ncPowerDownType->property_return)
1212
return AXIS2_SUCCESS;
1215
adb_ncPowerDownType_reset_return(_ncPowerDownType, env);
1217
_ncPowerDownType->property_return = arg_return;
1218
_ncPowerDownType->is_valid_return = AXIS2_TRUE;
1220
return AXIS2_SUCCESS;
1226
* resetter for return
1228
axis2_status_t AXIS2_CALL
1229
adb_ncPowerDownType_reset_return(
1230
adb_ncPowerDownType_t* _ncPowerDownType,
1231
const axutil_env_t *env)
1235
void *element = NULL;
1237
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1238
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
1241
_ncPowerDownType->is_valid_return = AXIS2_FALSE;
1242
return AXIS2_SUCCESS;
1246
* Check whether return is nill
1248
axis2_bool_t AXIS2_CALL
1249
adb_ncPowerDownType_is_return_nil(
1250
adb_ncPowerDownType_t* _ncPowerDownType,
1251
const axutil_env_t *env)
1253
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1254
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_TRUE);
1256
return !_ncPowerDownType->is_valid_return;
1260
* Set return to nill (currently the same as reset)
1262
axis2_status_t AXIS2_CALL
1263
adb_ncPowerDownType_set_return_nil(
1264
adb_ncPowerDownType_t* _ncPowerDownType,
1265
const axutil_env_t *env)
1267
return adb_ncPowerDownType_reset_return(_ncPowerDownType, env);
1273
* getter for statusMessage.
1276
adb_ncPowerDownType_get_statusMessage(
1277
adb_ncPowerDownType_t* _ncPowerDownType,
1278
const axutil_env_t *env)
1281
AXIS2_ENV_CHECK(env, (int)0);
1282
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, (int)0);
1285
return _ncPowerDownType->property_statusMessage;
1289
* setter for statusMessage
1291
axis2_status_t AXIS2_CALL
1292
adb_ncPowerDownType_set_statusMessage(
1293
adb_ncPowerDownType_t* _ncPowerDownType,
1294
const axutil_env_t *env,
1295
const int arg_statusMessage)
1299
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1300
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
1302
if(_ncPowerDownType->is_valid_statusMessage &&
1303
arg_statusMessage == _ncPowerDownType->property_statusMessage)
1306
return AXIS2_SUCCESS;
1309
adb_ncPowerDownType_reset_statusMessage(_ncPowerDownType, env);
1311
_ncPowerDownType->property_statusMessage = arg_statusMessage;
1312
_ncPowerDownType->is_valid_statusMessage = AXIS2_TRUE;
1314
return AXIS2_SUCCESS;
1320
* resetter for statusMessage
1322
axis2_status_t AXIS2_CALL
1323
adb_ncPowerDownType_reset_statusMessage(
1324
adb_ncPowerDownType_t* _ncPowerDownType,
1325
const axutil_env_t *env)
1329
void *element = NULL;
1331
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1332
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_FAILURE);
1335
_ncPowerDownType->is_valid_statusMessage = AXIS2_FALSE;
1336
return AXIS2_SUCCESS;
1340
* Check whether statusMessage is nill
1342
axis2_bool_t AXIS2_CALL
1343
adb_ncPowerDownType_is_statusMessage_nil(
1344
adb_ncPowerDownType_t* _ncPowerDownType,
1345
const axutil_env_t *env)
1347
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1348
AXIS2_PARAM_CHECK(env->error, _ncPowerDownType, AXIS2_TRUE);
1350
return !_ncPowerDownType->is_valid_statusMessage;
1354
* Set statusMessage to nill (currently the same as reset)
1356
axis2_status_t AXIS2_CALL
1357
adb_ncPowerDownType_set_statusMessage_nil(
1358
adb_ncPowerDownType_t* _ncPowerDownType,
1359
const axutil_env_t *env)
1361
return adb_ncPowerDownType_reset_statusMessage(_ncPowerDownType, env);