4
* adb_getConsoleOutputType.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_getConsoleOutputType.h"
13
* This type was generated from the piece of schema that had
14
* name = getConsoleOutputType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_getConsoleOutputType
23
axis2_char_t* property_correlationId;
26
axis2_bool_t is_valid_correlationId;
29
axis2_char_t* property_userId;
32
axis2_bool_t is_valid_userId;
35
axis2_char_t* property_statusMessage;
38
axis2_bool_t is_valid_statusMessage;
41
axis2_bool_t property_return;
44
axis2_bool_t is_valid_return;
47
axis2_char_t* property_instanceId;
50
axis2_bool_t is_valid_instanceId;
57
/************************* Private Function prototypes ********************************/
60
axis2_status_t AXIS2_CALL
61
adb_getConsoleOutputType_set_correlationId_nil(
62
adb_getConsoleOutputType_t* _getConsoleOutputType,
63
const axutil_env_t *env);
66
axis2_status_t AXIS2_CALL
67
adb_getConsoleOutputType_set_userId_nil(
68
adb_getConsoleOutputType_t* _getConsoleOutputType,
69
const axutil_env_t *env);
72
axis2_status_t AXIS2_CALL
73
adb_getConsoleOutputType_set_return_nil(
74
adb_getConsoleOutputType_t* _getConsoleOutputType,
75
const axutil_env_t *env);
78
axis2_status_t AXIS2_CALL
79
adb_getConsoleOutputType_set_instanceId_nil(
80
adb_getConsoleOutputType_t* _getConsoleOutputType,
81
const axutil_env_t *env);
85
/************************* Function Implmentations ********************************/
86
adb_getConsoleOutputType_t* AXIS2_CALL
87
adb_getConsoleOutputType_create(
88
const axutil_env_t *env)
90
adb_getConsoleOutputType_t *_getConsoleOutputType = NULL;
92
AXIS2_ENV_CHECK(env, NULL);
94
_getConsoleOutputType = (adb_getConsoleOutputType_t *) AXIS2_MALLOC(env->
95
allocator, sizeof(adb_getConsoleOutputType_t));
97
if(NULL == _getConsoleOutputType)
99
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
103
memset(_getConsoleOutputType, 0, sizeof(adb_getConsoleOutputType_t));
105
_getConsoleOutputType->property_correlationId = NULL;
106
_getConsoleOutputType->is_valid_correlationId = AXIS2_FALSE;
107
_getConsoleOutputType->property_userId = NULL;
108
_getConsoleOutputType->is_valid_userId = AXIS2_FALSE;
109
_getConsoleOutputType->property_statusMessage = NULL;
110
_getConsoleOutputType->is_valid_statusMessage = AXIS2_FALSE;
111
_getConsoleOutputType->is_valid_return = AXIS2_FALSE;
112
_getConsoleOutputType->property_instanceId = NULL;
113
_getConsoleOutputType->is_valid_instanceId = AXIS2_FALSE;
116
return _getConsoleOutputType;
119
axis2_status_t AXIS2_CALL
120
adb_getConsoleOutputType_free (
121
adb_getConsoleOutputType_t* _getConsoleOutputType,
122
const axutil_env_t *env)
126
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
127
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
129
adb_getConsoleOutputType_reset_correlationId(_getConsoleOutputType, env);
130
adb_getConsoleOutputType_reset_userId(_getConsoleOutputType, env);
131
adb_getConsoleOutputType_reset_statusMessage(_getConsoleOutputType, env);
132
adb_getConsoleOutputType_reset_return(_getConsoleOutputType, env);
133
adb_getConsoleOutputType_reset_instanceId(_getConsoleOutputType, env);
136
if(_getConsoleOutputType)
138
AXIS2_FREE(env->allocator, _getConsoleOutputType);
139
_getConsoleOutputType = NULL;
141
return AXIS2_SUCCESS;
147
axis2_status_t AXIS2_CALL
148
adb_getConsoleOutputType_deserialize(
149
adb_getConsoleOutputType_t* _getConsoleOutputType,
150
const axutil_env_t *env,
151
axiom_node_t **dp_parent,
152
axis2_bool_t *dp_is_early_node_valid,
153
axis2_bool_t dont_care_minoccurs)
155
axiom_node_t *parent = *dp_parent;
157
axis2_status_t status = AXIS2_SUCCESS;
159
axis2_char_t* text_value = NULL;
160
axutil_qname_t *qname = NULL;
162
axutil_qname_t *element_qname = NULL;
164
axiom_node_t *first_node = NULL;
165
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
166
axiom_node_t *current_node = NULL;
167
axiom_element_t *current_element = NULL;
169
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
170
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
174
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
176
parent = axiom_node_get_next_sibling(parent, env);
180
/* This should be checked before everything */
181
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
182
"Failed in building adb object for getConsoleOutputType : "
183
"NULL elemenet can not be passed to deserialize");
184
return AXIS2_FAILURE;
188
first_node = axiom_node_get_first_child(parent, env);
194
* building correlationId element
199
current_node = first_node;
200
is_early_node_valid = AXIS2_FALSE;
203
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
205
current_node = axiom_node_get_next_sibling(current_node, env);
207
if(current_node != NULL)
209
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
210
qname = axiom_element_get_qname(current_element, env, current_node);
213
element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
217
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
219
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
221
is_early_node_valid = AXIS2_TRUE;
225
text_value = axiom_element_get_text(current_element, env, current_node);
226
if(text_value != NULL)
228
status = adb_getConsoleOutputType_set_correlationId(_getConsoleOutputType, env,
235
* axis2_qname_t *qname = NULL;
236
* axiom_attribute_t *the_attri = NULL;
238
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
239
* the_attri = axiom_element_get_attribute(current_element, env, qname);
241
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
243
axiom_attribute_t *the_attri = NULL;
244
axis2_char_t *attrib_text = NULL;
245
axutil_hash_t *attribute_hash = NULL;
247
attribute_hash = axiom_element_get_all_attributes(current_element, env);
252
axutil_hash_index_t *hi;
256
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
258
axutil_hash_this(hi, &key, NULL, &val);
260
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
262
the_attri = (axiom_attribute_t*)val;
270
attrib_text = axiom_attribute_get_value(the_attri, env);
274
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
275
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
278
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
280
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
281
status = AXIS2_FAILURE;
285
/* after all, we found this is a empty string */
286
status = adb_getConsoleOutputType_set_correlationId(_getConsoleOutputType, env,
291
if(AXIS2_FAILURE == status)
293
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
296
axutil_qname_free(element_qname, env);
298
return AXIS2_FAILURE;
304
axutil_qname_free(element_qname, env);
305
element_qname = NULL;
311
* building userId element
317
* because elements are ordered this works fine
321
if(current_node != NULL && is_early_node_valid)
323
current_node = axiom_node_get_next_sibling(current_node, env);
326
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
328
current_node = axiom_node_get_next_sibling(current_node, env);
330
if(current_node != NULL)
332
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
333
qname = axiom_element_get_qname(current_element, env, current_node);
337
is_early_node_valid = AXIS2_FALSE;
339
element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
343
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
345
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
347
is_early_node_valid = AXIS2_TRUE;
351
text_value = axiom_element_get_text(current_element, env, current_node);
352
if(text_value != NULL)
354
status = adb_getConsoleOutputType_set_userId(_getConsoleOutputType, env,
361
* axis2_qname_t *qname = NULL;
362
* axiom_attribute_t *the_attri = NULL;
364
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
365
* the_attri = axiom_element_get_attribute(current_element, env, qname);
367
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
369
axiom_attribute_t *the_attri = NULL;
370
axis2_char_t *attrib_text = NULL;
371
axutil_hash_t *attribute_hash = NULL;
373
attribute_hash = axiom_element_get_all_attributes(current_element, env);
378
axutil_hash_index_t *hi;
382
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
384
axutil_hash_this(hi, &key, NULL, &val);
386
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
388
the_attri = (axiom_attribute_t*)val;
396
attrib_text = axiom_attribute_get_value(the_attri, env);
400
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
401
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
404
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
406
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
407
status = AXIS2_FAILURE;
411
/* after all, we found this is a empty string */
412
status = adb_getConsoleOutputType_set_userId(_getConsoleOutputType, env,
417
if(AXIS2_FAILURE == status)
419
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
422
axutil_qname_free(element_qname, env);
424
return AXIS2_FAILURE;
430
axutil_qname_free(element_qname, env);
431
element_qname = NULL;
437
* building statusMessage element
443
* because elements are ordered this works fine
447
if(current_node != NULL && is_early_node_valid)
449
current_node = axiom_node_get_next_sibling(current_node, env);
452
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
454
current_node = axiom_node_get_next_sibling(current_node, env);
456
if(current_node != NULL)
458
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
459
qname = axiom_element_get_qname(current_element, env, current_node);
463
is_early_node_valid = AXIS2_FALSE;
465
element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
469
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
471
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
473
is_early_node_valid = AXIS2_TRUE;
477
text_value = axiom_element_get_text(current_element, env, current_node);
478
if(text_value != NULL)
480
status = adb_getConsoleOutputType_set_statusMessage(_getConsoleOutputType, env,
484
if(AXIS2_FAILURE == status)
486
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
489
axutil_qname_free(element_qname, env);
491
return AXIS2_FAILURE;
497
axutil_qname_free(element_qname, env);
498
element_qname = NULL;
504
* building return element
510
* because elements are ordered this works fine
514
if(current_node != NULL && is_early_node_valid)
516
current_node = axiom_node_get_next_sibling(current_node, env);
519
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
521
current_node = axiom_node_get_next_sibling(current_node, env);
523
if(current_node != NULL)
525
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
526
qname = axiom_element_get_qname(current_element, env, current_node);
530
is_early_node_valid = AXIS2_FALSE;
532
element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
536
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
538
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
540
is_early_node_valid = AXIS2_TRUE;
544
text_value = axiom_element_get_text(current_element, env, current_node);
545
if(text_value != NULL)
547
if (!axutil_strcasecmp(text_value , "true"))
549
status = adb_getConsoleOutputType_set_return(_getConsoleOutputType, env,
554
status = adb_getConsoleOutputType_set_return(_getConsoleOutputType, env,
561
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
562
status = AXIS2_FAILURE;
565
if(AXIS2_FAILURE == status)
567
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
570
axutil_qname_free(element_qname, env);
572
return AXIS2_FAILURE;
578
axutil_qname_free(element_qname, env);
579
element_qname = NULL;
585
* building instanceId element
591
* because elements are ordered this works fine
595
if(current_node != NULL && is_early_node_valid)
597
current_node = axiom_node_get_next_sibling(current_node, env);
600
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
602
current_node = axiom_node_get_next_sibling(current_node, env);
604
if(current_node != NULL)
606
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
607
qname = axiom_element_get_qname(current_element, env, current_node);
611
is_early_node_valid = AXIS2_FALSE;
613
element_qname = axutil_qname_create(env, "instanceId", "http://eucalyptus.ucsb.edu/", NULL);
617
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
619
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
621
is_early_node_valid = AXIS2_TRUE;
625
text_value = axiom_element_get_text(current_element, env, current_node);
626
if(text_value != NULL)
628
status = adb_getConsoleOutputType_set_instanceId(_getConsoleOutputType, env,
635
* axis2_qname_t *qname = NULL;
636
* axiom_attribute_t *the_attri = NULL;
638
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
639
* the_attri = axiom_element_get_attribute(current_element, env, qname);
641
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
643
axiom_attribute_t *the_attri = NULL;
644
axis2_char_t *attrib_text = NULL;
645
axutil_hash_t *attribute_hash = NULL;
647
attribute_hash = axiom_element_get_all_attributes(current_element, env);
652
axutil_hash_index_t *hi;
656
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
658
axutil_hash_this(hi, &key, NULL, &val);
660
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
662
the_attri = (axiom_attribute_t*)val;
670
attrib_text = axiom_attribute_get_value(the_attri, env);
674
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
675
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
678
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
680
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceId");
681
status = AXIS2_FAILURE;
685
/* after all, we found this is a empty string */
686
status = adb_getConsoleOutputType_set_instanceId(_getConsoleOutputType, env,
691
if(AXIS2_FAILURE == status)
693
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceId ");
696
axutil_qname_free(element_qname, env);
698
return AXIS2_FAILURE;
704
axutil_qname_free(element_qname, env);
705
element_qname = NULL;
711
axis2_bool_t AXIS2_CALL
712
adb_getConsoleOutputType_is_particle()
721
adb_getConsoleOutputType_declare_parent_namespaces(
722
adb_getConsoleOutputType_t* _getConsoleOutputType,
723
const axutil_env_t *env, axiom_element_t *parent_element,
724
axutil_hash_t *namespaces, int *next_ns_index)
727
/* Here this is an empty function, Nothing to declare */
733
axiom_node_t* AXIS2_CALL
734
adb_getConsoleOutputType_serialize(
735
adb_getConsoleOutputType_t* _getConsoleOutputType,
736
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)
740
axis2_char_t *string_to_stream;
743
axiom_node_t *current_node = NULL;
748
axiom_namespace_t *ns1 = NULL;
750
axis2_char_t *qname_uri = NULL;
751
axis2_char_t *qname_prefix = NULL;
752
axis2_char_t *p_prefix = NULL;
753
axis2_bool_t ns_already_defined;
755
axis2_char_t *text_value_1;
756
axis2_char_t *text_value_1_temp;
758
axis2_char_t *text_value_2;
759
axis2_char_t *text_value_2_temp;
761
axis2_char_t *text_value_3;
762
axis2_char_t *text_value_3_temp;
764
axis2_char_t text_value_4[64];
766
axis2_char_t *text_value_5;
767
axis2_char_t *text_value_5_temp;
769
axis2_char_t *start_input_str = NULL;
770
axis2_char_t *end_input_str = NULL;
771
unsigned int start_input_str_len = 0;
772
unsigned int end_input_str_len = 0;
775
axiom_data_source_t *data_source = NULL;
776
axutil_stream_t *stream = NULL;
780
AXIS2_ENV_CHECK(env, NULL);
781
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, NULL);
784
current_node = parent;
785
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
788
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
792
if(!parent_tag_closed)
795
string_to_stream = ">";
796
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
801
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
803
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
804
sprintf(p_prefix, "n%d", (*next_ns_index)++);
805
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
807
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
808
"http://eucalyptus.ucsb.edu/",
813
if (!_getConsoleOutputType->is_valid_correlationId)
816
/* no need to complain for minoccurs=0 element */
822
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
823
(4 + axutil_strlen(p_prefix) +
824
axutil_strlen("correlationId")));
826
/* axutil_strlen("<:>") + 1 = 4 */
827
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
828
(5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
829
/* axutil_strlen("</:>") + 1 = 5 */
837
* parsing correlationId element
842
sprintf(start_input_str, "<%s%scorrelationId>",
843
p_prefix?p_prefix:"",
844
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
846
start_input_str_len = axutil_strlen(start_input_str);
847
sprintf(end_input_str, "</%s%scorrelationId>",
848
p_prefix?p_prefix:"",
849
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
850
end_input_str_len = axutil_strlen(end_input_str);
852
text_value_1 = _getConsoleOutputType->property_correlationId;
854
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
857
text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
858
if (text_value_1_temp)
860
axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
861
AXIS2_FREE(env->allocator, text_value_1_temp);
865
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
868
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
871
AXIS2_FREE(env->allocator,start_input_str);
872
AXIS2_FREE(env->allocator,end_input_str);
876
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
878
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
879
sprintf(p_prefix, "n%d", (*next_ns_index)++);
880
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
882
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
883
"http://eucalyptus.ucsb.edu/",
888
if (!_getConsoleOutputType->is_valid_userId)
891
/* no need to complain for minoccurs=0 element */
897
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
898
(4 + axutil_strlen(p_prefix) +
899
axutil_strlen("userId")));
901
/* axutil_strlen("<:>") + 1 = 4 */
902
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
903
(5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
904
/* axutil_strlen("</:>") + 1 = 5 */
912
* parsing userId element
917
sprintf(start_input_str, "<%s%suserId>",
918
p_prefix?p_prefix:"",
919
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
921
start_input_str_len = axutil_strlen(start_input_str);
922
sprintf(end_input_str, "</%s%suserId>",
923
p_prefix?p_prefix:"",
924
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
925
end_input_str_len = axutil_strlen(end_input_str);
927
text_value_2 = _getConsoleOutputType->property_userId;
929
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
932
text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
933
if (text_value_2_temp)
935
axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
936
AXIS2_FREE(env->allocator, text_value_2_temp);
940
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
943
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
946
AXIS2_FREE(env->allocator,start_input_str);
947
AXIS2_FREE(env->allocator,end_input_str);
951
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
953
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
954
sprintf(p_prefix, "n%d", (*next_ns_index)++);
955
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
957
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
958
"http://eucalyptus.ucsb.edu/",
963
if (!_getConsoleOutputType->is_valid_statusMessage)
966
/* no need to complain for minoccurs=0 element */
972
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
973
(4 + axutil_strlen(p_prefix) +
974
axutil_strlen("statusMessage")));
976
/* axutil_strlen("<:>") + 1 = 4 */
977
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
978
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
979
/* axutil_strlen("</:>") + 1 = 5 */
987
* parsing statusMessage element
992
sprintf(start_input_str, "<%s%sstatusMessage>",
993
p_prefix?p_prefix:"",
994
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
996
start_input_str_len = axutil_strlen(start_input_str);
997
sprintf(end_input_str, "</%s%sstatusMessage>",
998
p_prefix?p_prefix:"",
999
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1000
end_input_str_len = axutil_strlen(end_input_str);
1002
text_value_3 = _getConsoleOutputType->property_statusMessage;
1004
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1007
text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1008
if (text_value_3_temp)
1010
axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
1011
AXIS2_FREE(env->allocator, text_value_3_temp);
1015
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1018
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1021
AXIS2_FREE(env->allocator,start_input_str);
1022
AXIS2_FREE(env->allocator,end_input_str);
1026
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1028
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1029
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1030
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1032
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1033
"http://eucalyptus.ucsb.edu/",
1038
if (!_getConsoleOutputType->is_valid_return)
1041
/* no need to complain for minoccurs=0 element */
1047
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1048
(4 + axutil_strlen(p_prefix) +
1049
axutil_strlen("return")));
1051
/* axutil_strlen("<:>") + 1 = 4 */
1052
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1053
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1054
/* axutil_strlen("</:>") + 1 = 5 */
1062
* parsing return element
1067
sprintf(start_input_str, "<%s%sreturn>",
1068
p_prefix?p_prefix:"",
1069
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1071
start_input_str_len = axutil_strlen(start_input_str);
1072
sprintf(end_input_str, "</%s%sreturn>",
1073
p_prefix?p_prefix:"",
1074
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1075
end_input_str_len = axutil_strlen(end_input_str);
1077
strcpy(text_value_4, (_getConsoleOutputType->property_return)?"true":"false");
1079
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1081
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1083
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1086
AXIS2_FREE(env->allocator,start_input_str);
1087
AXIS2_FREE(env->allocator,end_input_str);
1091
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1093
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1094
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1095
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1097
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1098
"http://eucalyptus.ucsb.edu/",
1103
if (!_getConsoleOutputType->is_valid_instanceId)
1106
/* no need to complain for minoccurs=0 element */
1112
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1113
(4 + axutil_strlen(p_prefix) +
1114
axutil_strlen("instanceId")));
1116
/* axutil_strlen("<:>") + 1 = 4 */
1117
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1118
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceId")));
1119
/* axutil_strlen("</:>") + 1 = 5 */
1127
* parsing instanceId element
1132
sprintf(start_input_str, "<%s%sinstanceId>",
1133
p_prefix?p_prefix:"",
1134
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1136
start_input_str_len = axutil_strlen(start_input_str);
1137
sprintf(end_input_str, "</%s%sinstanceId>",
1138
p_prefix?p_prefix:"",
1139
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1140
end_input_str_len = axutil_strlen(end_input_str);
1142
text_value_5 = _getConsoleOutputType->property_instanceId;
1144
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1147
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1148
if (text_value_5_temp)
1150
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1151
AXIS2_FREE(env->allocator, text_value_5_temp);
1155
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1158
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1161
AXIS2_FREE(env->allocator,start_input_str);
1162
AXIS2_FREE(env->allocator,end_input_str);
1174
* getter for correlationId.
1176
axis2_char_t* AXIS2_CALL
1177
adb_getConsoleOutputType_get_correlationId(
1178
adb_getConsoleOutputType_t* _getConsoleOutputType,
1179
const axutil_env_t *env)
1182
AXIS2_ENV_CHECK(env, NULL);
1183
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, NULL);
1186
return _getConsoleOutputType->property_correlationId;
1190
* setter for correlationId
1192
axis2_status_t AXIS2_CALL
1193
adb_getConsoleOutputType_set_correlationId(
1194
adb_getConsoleOutputType_t* _getConsoleOutputType,
1195
const axutil_env_t *env,
1196
const axis2_char_t* arg_correlationId)
1200
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1201
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1203
if(_getConsoleOutputType->is_valid_correlationId &&
1204
arg_correlationId == _getConsoleOutputType->property_correlationId)
1207
return AXIS2_SUCCESS;
1210
adb_getConsoleOutputType_reset_correlationId(_getConsoleOutputType, env);
1213
if(NULL == arg_correlationId)
1215
/* We are already done */
1216
return AXIS2_SUCCESS;
1218
_getConsoleOutputType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
1219
if(NULL == _getConsoleOutputType->property_correlationId)
1221
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
1222
return AXIS2_FAILURE;
1224
_getConsoleOutputType->is_valid_correlationId = AXIS2_TRUE;
1226
return AXIS2_SUCCESS;
1232
* resetter for correlationId
1234
axis2_status_t AXIS2_CALL
1235
adb_getConsoleOutputType_reset_correlationId(
1236
adb_getConsoleOutputType_t* _getConsoleOutputType,
1237
const axutil_env_t *env)
1241
void *element = NULL;
1243
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1244
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1250
if(_getConsoleOutputType->property_correlationId != NULL)
1254
AXIS2_FREE(env-> allocator, _getConsoleOutputType->property_correlationId);
1255
_getConsoleOutputType->property_correlationId = NULL;
1260
_getConsoleOutputType->is_valid_correlationId = AXIS2_FALSE;
1261
return AXIS2_SUCCESS;
1265
* Check whether correlationId is nill
1267
axis2_bool_t AXIS2_CALL
1268
adb_getConsoleOutputType_is_correlationId_nil(
1269
adb_getConsoleOutputType_t* _getConsoleOutputType,
1270
const axutil_env_t *env)
1272
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1273
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_TRUE);
1275
return !_getConsoleOutputType->is_valid_correlationId;
1279
* Set correlationId to nill (currently the same as reset)
1281
axis2_status_t AXIS2_CALL
1282
adb_getConsoleOutputType_set_correlationId_nil(
1283
adb_getConsoleOutputType_t* _getConsoleOutputType,
1284
const axutil_env_t *env)
1286
return adb_getConsoleOutputType_reset_correlationId(_getConsoleOutputType, env);
1292
* getter for userId.
1294
axis2_char_t* AXIS2_CALL
1295
adb_getConsoleOutputType_get_userId(
1296
adb_getConsoleOutputType_t* _getConsoleOutputType,
1297
const axutil_env_t *env)
1300
AXIS2_ENV_CHECK(env, NULL);
1301
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, NULL);
1304
return _getConsoleOutputType->property_userId;
1310
axis2_status_t AXIS2_CALL
1311
adb_getConsoleOutputType_set_userId(
1312
adb_getConsoleOutputType_t* _getConsoleOutputType,
1313
const axutil_env_t *env,
1314
const axis2_char_t* arg_userId)
1318
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1319
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1321
if(_getConsoleOutputType->is_valid_userId &&
1322
arg_userId == _getConsoleOutputType->property_userId)
1325
return AXIS2_SUCCESS;
1328
adb_getConsoleOutputType_reset_userId(_getConsoleOutputType, env);
1331
if(NULL == arg_userId)
1333
/* We are already done */
1334
return AXIS2_SUCCESS;
1336
_getConsoleOutputType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
1337
if(NULL == _getConsoleOutputType->property_userId)
1339
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
1340
return AXIS2_FAILURE;
1342
_getConsoleOutputType->is_valid_userId = AXIS2_TRUE;
1344
return AXIS2_SUCCESS;
1350
* resetter for userId
1352
axis2_status_t AXIS2_CALL
1353
adb_getConsoleOutputType_reset_userId(
1354
adb_getConsoleOutputType_t* _getConsoleOutputType,
1355
const axutil_env_t *env)
1359
void *element = NULL;
1361
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1362
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1368
if(_getConsoleOutputType->property_userId != NULL)
1372
AXIS2_FREE(env-> allocator, _getConsoleOutputType->property_userId);
1373
_getConsoleOutputType->property_userId = NULL;
1378
_getConsoleOutputType->is_valid_userId = AXIS2_FALSE;
1379
return AXIS2_SUCCESS;
1383
* Check whether userId is nill
1385
axis2_bool_t AXIS2_CALL
1386
adb_getConsoleOutputType_is_userId_nil(
1387
adb_getConsoleOutputType_t* _getConsoleOutputType,
1388
const axutil_env_t *env)
1390
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1391
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_TRUE);
1393
return !_getConsoleOutputType->is_valid_userId;
1397
* Set userId to nill (currently the same as reset)
1399
axis2_status_t AXIS2_CALL
1400
adb_getConsoleOutputType_set_userId_nil(
1401
adb_getConsoleOutputType_t* _getConsoleOutputType,
1402
const axutil_env_t *env)
1404
return adb_getConsoleOutputType_reset_userId(_getConsoleOutputType, env);
1410
* getter for statusMessage.
1412
axis2_char_t* AXIS2_CALL
1413
adb_getConsoleOutputType_get_statusMessage(
1414
adb_getConsoleOutputType_t* _getConsoleOutputType,
1415
const axutil_env_t *env)
1418
AXIS2_ENV_CHECK(env, NULL);
1419
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, NULL);
1422
return _getConsoleOutputType->property_statusMessage;
1426
* setter for statusMessage
1428
axis2_status_t AXIS2_CALL
1429
adb_getConsoleOutputType_set_statusMessage(
1430
adb_getConsoleOutputType_t* _getConsoleOutputType,
1431
const axutil_env_t *env,
1432
const axis2_char_t* arg_statusMessage)
1436
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1437
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1439
if(_getConsoleOutputType->is_valid_statusMessage &&
1440
arg_statusMessage == _getConsoleOutputType->property_statusMessage)
1443
return AXIS2_SUCCESS;
1446
adb_getConsoleOutputType_reset_statusMessage(_getConsoleOutputType, env);
1449
if(NULL == arg_statusMessage)
1451
/* We are already done */
1452
return AXIS2_SUCCESS;
1454
_getConsoleOutputType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
1455
if(NULL == _getConsoleOutputType->property_statusMessage)
1457
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
1458
return AXIS2_FAILURE;
1460
_getConsoleOutputType->is_valid_statusMessage = AXIS2_TRUE;
1462
return AXIS2_SUCCESS;
1468
* resetter for statusMessage
1470
axis2_status_t AXIS2_CALL
1471
adb_getConsoleOutputType_reset_statusMessage(
1472
adb_getConsoleOutputType_t* _getConsoleOutputType,
1473
const axutil_env_t *env)
1477
void *element = NULL;
1479
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1480
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1486
if(_getConsoleOutputType->property_statusMessage != NULL)
1490
AXIS2_FREE(env-> allocator, _getConsoleOutputType->property_statusMessage);
1491
_getConsoleOutputType->property_statusMessage = NULL;
1496
_getConsoleOutputType->is_valid_statusMessage = AXIS2_FALSE;
1497
return AXIS2_SUCCESS;
1501
* Check whether statusMessage is nill
1503
axis2_bool_t AXIS2_CALL
1504
adb_getConsoleOutputType_is_statusMessage_nil(
1505
adb_getConsoleOutputType_t* _getConsoleOutputType,
1506
const axutil_env_t *env)
1508
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1509
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_TRUE);
1511
return !_getConsoleOutputType->is_valid_statusMessage;
1515
* Set statusMessage to nill (currently the same as reset)
1517
axis2_status_t AXIS2_CALL
1518
adb_getConsoleOutputType_set_statusMessage_nil(
1519
adb_getConsoleOutputType_t* _getConsoleOutputType,
1520
const axutil_env_t *env)
1522
return adb_getConsoleOutputType_reset_statusMessage(_getConsoleOutputType, env);
1528
* getter for return.
1530
axis2_bool_t AXIS2_CALL
1531
adb_getConsoleOutputType_get_return(
1532
adb_getConsoleOutputType_t* _getConsoleOutputType,
1533
const axutil_env_t *env)
1536
AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1537
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, (axis2_bool_t)0);
1540
return _getConsoleOutputType->property_return;
1546
axis2_status_t AXIS2_CALL
1547
adb_getConsoleOutputType_set_return(
1548
adb_getConsoleOutputType_t* _getConsoleOutputType,
1549
const axutil_env_t *env,
1550
axis2_bool_t arg_return)
1554
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1555
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1557
if(_getConsoleOutputType->is_valid_return &&
1558
arg_return == _getConsoleOutputType->property_return)
1561
return AXIS2_SUCCESS;
1564
adb_getConsoleOutputType_reset_return(_getConsoleOutputType, env);
1566
_getConsoleOutputType->property_return = arg_return;
1567
_getConsoleOutputType->is_valid_return = AXIS2_TRUE;
1569
return AXIS2_SUCCESS;
1575
* resetter for return
1577
axis2_status_t AXIS2_CALL
1578
adb_getConsoleOutputType_reset_return(
1579
adb_getConsoleOutputType_t* _getConsoleOutputType,
1580
const axutil_env_t *env)
1584
void *element = NULL;
1586
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1587
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1590
_getConsoleOutputType->is_valid_return = AXIS2_FALSE;
1591
return AXIS2_SUCCESS;
1595
* Check whether return is nill
1597
axis2_bool_t AXIS2_CALL
1598
adb_getConsoleOutputType_is_return_nil(
1599
adb_getConsoleOutputType_t* _getConsoleOutputType,
1600
const axutil_env_t *env)
1602
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1603
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_TRUE);
1605
return !_getConsoleOutputType->is_valid_return;
1609
* Set return to nill (currently the same as reset)
1611
axis2_status_t AXIS2_CALL
1612
adb_getConsoleOutputType_set_return_nil(
1613
adb_getConsoleOutputType_t* _getConsoleOutputType,
1614
const axutil_env_t *env)
1616
return adb_getConsoleOutputType_reset_return(_getConsoleOutputType, env);
1622
* getter for instanceId.
1624
axis2_char_t* AXIS2_CALL
1625
adb_getConsoleOutputType_get_instanceId(
1626
adb_getConsoleOutputType_t* _getConsoleOutputType,
1627
const axutil_env_t *env)
1630
AXIS2_ENV_CHECK(env, NULL);
1631
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, NULL);
1634
return _getConsoleOutputType->property_instanceId;
1638
* setter for instanceId
1640
axis2_status_t AXIS2_CALL
1641
adb_getConsoleOutputType_set_instanceId(
1642
adb_getConsoleOutputType_t* _getConsoleOutputType,
1643
const axutil_env_t *env,
1644
const axis2_char_t* arg_instanceId)
1648
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1649
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1651
if(_getConsoleOutputType->is_valid_instanceId &&
1652
arg_instanceId == _getConsoleOutputType->property_instanceId)
1655
return AXIS2_SUCCESS;
1658
adb_getConsoleOutputType_reset_instanceId(_getConsoleOutputType, env);
1661
if(NULL == arg_instanceId)
1663
/* We are already done */
1664
return AXIS2_SUCCESS;
1666
_getConsoleOutputType->property_instanceId = (axis2_char_t *)axutil_strdup(env, arg_instanceId);
1667
if(NULL == _getConsoleOutputType->property_instanceId)
1669
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for instanceId");
1670
return AXIS2_FAILURE;
1672
_getConsoleOutputType->is_valid_instanceId = AXIS2_TRUE;
1674
return AXIS2_SUCCESS;
1680
* resetter for instanceId
1682
axis2_status_t AXIS2_CALL
1683
adb_getConsoleOutputType_reset_instanceId(
1684
adb_getConsoleOutputType_t* _getConsoleOutputType,
1685
const axutil_env_t *env)
1689
void *element = NULL;
1691
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1692
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_FAILURE);
1698
if(_getConsoleOutputType->property_instanceId != NULL)
1702
AXIS2_FREE(env-> allocator, _getConsoleOutputType->property_instanceId);
1703
_getConsoleOutputType->property_instanceId = NULL;
1708
_getConsoleOutputType->is_valid_instanceId = AXIS2_FALSE;
1709
return AXIS2_SUCCESS;
1713
* Check whether instanceId is nill
1715
axis2_bool_t AXIS2_CALL
1716
adb_getConsoleOutputType_is_instanceId_nil(
1717
adb_getConsoleOutputType_t* _getConsoleOutputType,
1718
const axutil_env_t *env)
1720
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1721
AXIS2_PARAM_CHECK(env->error, _getConsoleOutputType, AXIS2_TRUE);
1723
return !_getConsoleOutputType->is_valid_instanceId;
1727
* Set instanceId to nill (currently the same as reset)
1729
axis2_status_t AXIS2_CALL
1730
adb_getConsoleOutputType_set_instanceId_nil(
1731
adb_getConsoleOutputType_t* _getConsoleOutputType,
1732
const axutil_env_t *env)
1734
return adb_getConsoleOutputType_reset_instanceId(_getConsoleOutputType, env);