10
10
#include "adb_ncAttachVolumeType.h"
13
13
* This type was generated from the piece of schema that had
14
14
* name = ncAttachVolumeType
15
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
16
* Namespace Prefix = ns1
21
21
struct adb_ncAttachVolumeType
23
23
axis2_char_t* property_correlationId;
26
26
axis2_bool_t is_valid_correlationId;
29
29
axis2_char_t* property_userId;
32
32
axis2_bool_t is_valid_userId;
35
35
axis2_bool_t property_return;
38
38
axis2_bool_t is_valid_return;
41
axis2_char_t* property_nodeName;
44
axis2_bool_t is_valid_nodeName;
41
47
int property_statusMessage;
44
50
axis2_bool_t is_valid_statusMessage;
53
axis2_char_t* property_instanceId;
56
axis2_bool_t is_valid_instanceId;
47
59
axis2_char_t* property_volumeId;
50
62
axis2_bool_t is_valid_volumeId;
53
axis2_char_t* property_instanceId;
56
axis2_bool_t is_valid_instanceId;
59
65
axis2_char_t* property_remoteDev;
62
68
axis2_bool_t is_valid_remoteDev;
65
71
axis2_char_t* property_localDev;
68
74
axis2_bool_t is_valid_localDev;
75
81
/************************* Private Function prototypes ********************************/
78
axis2_status_t AXIS2_CALL
79
adb_ncAttachVolumeType_set_correlationId_nil(
80
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
81
const axutil_env_t *env);
84
84
axis2_status_t AXIS2_CALL
85
85
adb_ncAttachVolumeType_set_userId_nil(
86
86
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
87
87
const axutil_env_t *env);
90
90
axis2_status_t AXIS2_CALL
91
91
adb_ncAttachVolumeType_set_return_nil(
92
92
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
93
93
const axutil_env_t *env);
96
axis2_status_t AXIS2_CALL
97
adb_ncAttachVolumeType_set_instanceId_nil(
98
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
99
const axutil_env_t *env);
96
102
axis2_status_t AXIS2_CALL
97
103
adb_ncAttachVolumeType_set_volumeId_nil(
98
104
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
99
105
const axutil_env_t *env);
102
axis2_status_t AXIS2_CALL
103
adb_ncAttachVolumeType_set_instanceId_nil(
104
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
105
const axutil_env_t *env);
108
108
axis2_status_t AXIS2_CALL
109
109
adb_ncAttachVolumeType_set_remoteDev_nil(
110
110
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
111
111
const axutil_env_t *env);
114
114
axis2_status_t AXIS2_CALL
115
115
adb_ncAttachVolumeType_set_localDev_nil(
116
116
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
117
117
const axutil_env_t *env);
121
121
/************************* Function Implmentations ********************************/
616
627
return AXIS2_FAILURE;
622
axutil_qname_free(element_qname, env);
623
element_qname = NULL;
633
axutil_qname_free(element_qname, env);
634
element_qname = NULL;
640
* building instanceId element
646
* because elements are ordered this works fine
650
if(current_node != NULL && is_early_node_valid)
652
current_node = axiom_node_get_next_sibling(current_node, env);
655
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
657
current_node = axiom_node_get_next_sibling(current_node, env);
659
if(current_node != NULL)
661
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
662
qname = axiom_element_get_qname(current_element, env, current_node);
666
is_early_node_valid = AXIS2_FALSE;
668
element_qname = axutil_qname_create(env, "instanceId", "http://eucalyptus.ucsb.edu/", NULL);
672
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
674
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
676
is_early_node_valid = AXIS2_TRUE;
680
text_value = axiom_element_get_text(current_element, env, current_node);
681
if(text_value != NULL)
683
status = adb_ncAttachVolumeType_set_instanceId(_ncAttachVolumeType, env,
690
* axis2_qname_t *qname = NULL;
691
* axiom_attribute_t *the_attri = NULL;
693
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
694
* the_attri = axiom_element_get_attribute(current_element, env, qname);
696
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
698
axiom_attribute_t *the_attri = NULL;
699
axis2_char_t *attrib_text = NULL;
700
axutil_hash_t *attribute_hash = NULL;
702
attribute_hash = axiom_element_get_all_attributes(current_element, env);
707
axutil_hash_index_t *hi;
711
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
713
axutil_hash_this(hi, &key, NULL, &val);
715
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
717
the_attri = (axiom_attribute_t*)val;
725
attrib_text = axiom_attribute_get_value(the_attri, env);
729
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
730
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
733
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
735
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceId");
736
status = AXIS2_FAILURE;
740
/* after all, we found this is a empty string */
741
status = adb_ncAttachVolumeType_set_instanceId(_ncAttachVolumeType, env,
746
if(AXIS2_FAILURE == status)
748
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceId ");
751
axutil_qname_free(element_qname, env);
753
return AXIS2_FAILURE;
759
axutil_qname_free(element_qname, env);
760
element_qname = NULL;
629
766
* building volumeId element
635
772
* because elements are ordered this works fine
639
776
if(current_node != NULL && is_early_node_valid)
641
778
current_node = axiom_node_get_next_sibling(current_node, env);
644
781
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
646
783
current_node = axiom_node_get_next_sibling(current_node, env);
742
879
return AXIS2_FAILURE;
748
axutil_qname_free(element_qname, env);
749
element_qname = NULL;
755
* building instanceId element
761
* because elements are ordered this works fine
765
if(current_node != NULL && is_early_node_valid)
767
current_node = axiom_node_get_next_sibling(current_node, env);
770
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
772
current_node = axiom_node_get_next_sibling(current_node, env);
774
if(current_node != NULL)
776
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
777
qname = axiom_element_get_qname(current_element, env, current_node);
781
is_early_node_valid = AXIS2_FALSE;
783
element_qname = axutil_qname_create(env, "instanceId", "http://eucalyptus.ucsb.edu/", NULL);
787
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
789
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
791
is_early_node_valid = AXIS2_TRUE;
795
text_value = axiom_element_get_text(current_element, env, current_node);
796
if(text_value != NULL)
798
status = adb_ncAttachVolumeType_set_instanceId(_ncAttachVolumeType, env,
805
* axis2_qname_t *qname = NULL;
806
* axiom_attribute_t *the_attri = NULL;
808
* qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
809
* the_attri = axiom_element_get_attribute(current_element, env, qname);
811
/* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
813
axiom_attribute_t *the_attri = NULL;
814
axis2_char_t *attrib_text = NULL;
815
axutil_hash_t *attribute_hash = NULL;
817
attribute_hash = axiom_element_get_all_attributes(current_element, env);
822
axutil_hash_index_t *hi;
826
for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
828
axutil_hash_this(hi, &key, NULL, &val);
830
if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
832
the_attri = (axiom_attribute_t*)val;
840
attrib_text = axiom_attribute_get_value(the_attri, env);
844
/* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
845
attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
848
if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
850
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceId");
851
status = AXIS2_FAILURE;
855
/* after all, we found this is a empty string */
856
status = adb_ncAttachVolumeType_set_instanceId(_ncAttachVolumeType, env,
861
if(AXIS2_FAILURE == status)
863
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceId ");
866
axutil_qname_free(element_qname, env);
868
return AXIS2_FAILURE;
874
axutil_qname_free(element_qname, env);
875
element_qname = NULL;
885
axutil_qname_free(element_qname, env);
886
element_qname = NULL;
881
892
* building remoteDev element
887
898
* because elements are ordered this works fine
891
902
if(current_node != NULL && is_early_node_valid)
893
904
current_node = axiom_node_get_next_sibling(current_node, env);
896
907
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
898
909
current_node = axiom_node_get_next_sibling(current_node, env);
1370
1384
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1373
1387
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1376
1390
AXIS2_FREE(env->allocator,start_input_str);
1377
1391
AXIS2_FREE(env->allocator,end_input_str);
1381
1395
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1383
1397
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1384
1398
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1385
1399
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1387
1401
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1388
1402
"http://eucalyptus.ucsb.edu/",
1393
1407
if (!_ncAttachVolumeType->is_valid_return)
1396
1410
/* no need to complain for minoccurs=0 element */
1402
1416
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1403
(4 + axutil_strlen(p_prefix) +
1404
axutil_strlen("return")));
1417
(4 + axutil_strlen(p_prefix) +
1418
axutil_strlen("return")));
1406
1420
/* axutil_strlen("<:>") + 1 = 4 */
1407
1421
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1408
1422
(5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1409
1423
/* axutil_strlen("</:>") + 1 = 5 */
1417
1431
* parsing return element
1422
1436
sprintf(start_input_str, "<%s%sreturn>",
1423
1437
p_prefix?p_prefix:"",
1424
1438
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1426
1440
start_input_str_len = axutil_strlen(start_input_str);
1427
1441
sprintf(end_input_str, "</%s%sreturn>",
1428
1442
p_prefix?p_prefix:"",
1429
1443
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1430
1444
end_input_str_len = axutil_strlen(end_input_str);
1432
1446
strcpy(text_value_3, (_ncAttachVolumeType->property_return)?"true":"false");
1434
1448
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1436
1450
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1438
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1441
AXIS2_FREE(env->allocator,start_input_str);
1442
AXIS2_FREE(env->allocator,end_input_str);
1446
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1448
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1449
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1450
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1452
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1453
"http://eucalyptus.ucsb.edu/",
1452
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1455
AXIS2_FREE(env->allocator,start_input_str);
1456
AXIS2_FREE(env->allocator,end_input_str);
1460
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1462
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1463
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1464
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1466
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1467
"http://eucalyptus.ucsb.edu/",
1472
if (!_ncAttachVolumeType->is_valid_nodeName)
1475
/* no need to complain for minoccurs=0 element */
1481
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1482
(4 + axutil_strlen(p_prefix) +
1483
axutil_strlen("nodeName")));
1485
/* axutil_strlen("<:>") + 1 = 4 */
1486
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1487
(5 + axutil_strlen(p_prefix) + axutil_strlen("nodeName")));
1488
/* axutil_strlen("</:>") + 1 = 5 */
1496
* parsing nodeName element
1501
sprintf(start_input_str, "<%s%snodeName>",
1502
p_prefix?p_prefix:"",
1503
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1505
start_input_str_len = axutil_strlen(start_input_str);
1506
sprintf(end_input_str, "</%s%snodeName>",
1507
p_prefix?p_prefix:"",
1508
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1509
end_input_str_len = axutil_strlen(end_input_str);
1511
text_value_4 = _ncAttachVolumeType->property_nodeName;
1513
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1516
text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
1517
if (text_value_4_temp)
1519
axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
1520
AXIS2_FREE(env->allocator, text_value_4_temp);
1524
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1527
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1530
AXIS2_FREE(env->allocator,start_input_str);
1531
AXIS2_FREE(env->allocator,end_input_str);
1535
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1537
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1538
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1539
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1541
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1542
"http://eucalyptus.ucsb.edu/",
1458
1547
if (!_ncAttachVolumeType->is_valid_statusMessage)
1461
1550
/* no need to complain for minoccurs=0 element */
1467
1556
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1468
(4 + axutil_strlen(p_prefix) +
1469
axutil_strlen("statusMessage")));
1557
(4 + axutil_strlen(p_prefix) +
1558
axutil_strlen("statusMessage")));
1471
1560
/* axutil_strlen("<:>") + 1 = 4 */
1472
1561
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1473
1562
(5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1474
1563
/* axutil_strlen("</:>") + 1 = 5 */
1482
1571
* parsing statusMessage element
1487
1576
sprintf(start_input_str, "<%s%sstatusMessage>",
1488
1577
p_prefix?p_prefix:"",
1489
1578
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1491
1580
start_input_str_len = axutil_strlen(start_input_str);
1492
1581
sprintf(end_input_str, "</%s%sstatusMessage>",
1493
1582
p_prefix?p_prefix:"",
1494
1583
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1495
1584
end_input_str_len = axutil_strlen(end_input_str);
1497
sprintf (text_value_4, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncAttachVolumeType->property_statusMessage);
1499
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1501
axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1503
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1506
AXIS2_FREE(env->allocator,start_input_str);
1507
AXIS2_FREE(env->allocator,end_input_str);
1511
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1513
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1514
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1515
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1517
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1518
"http://eucalyptus.ucsb.edu/",
1523
if (!_ncAttachVolumeType->is_valid_volumeId)
1526
/* no need to complain for minoccurs=0 element */
1532
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1533
(4 + axutil_strlen(p_prefix) +
1534
axutil_strlen("volumeId")));
1536
/* axutil_strlen("<:>") + 1 = 4 */
1537
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1538
(5 + axutil_strlen(p_prefix) + axutil_strlen("volumeId")));
1539
/* axutil_strlen("</:>") + 1 = 5 */
1547
* parsing volumeId element
1552
sprintf(start_input_str, "<%s%svolumeId>",
1553
p_prefix?p_prefix:"",
1554
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1556
start_input_str_len = axutil_strlen(start_input_str);
1557
sprintf(end_input_str, "</%s%svolumeId>",
1558
p_prefix?p_prefix:"",
1559
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1560
end_input_str_len = axutil_strlen(end_input_str);
1562
text_value_5 = _ncAttachVolumeType->property_volumeId;
1564
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1567
text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1568
if (text_value_5_temp)
1570
axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1571
AXIS2_FREE(env->allocator, text_value_5_temp);
1575
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1578
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1581
AXIS2_FREE(env->allocator,start_input_str);
1582
AXIS2_FREE(env->allocator,end_input_str);
1586
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1588
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1589
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1590
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1592
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1593
"http://eucalyptus.ucsb.edu/",
1586
sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncAttachVolumeType->property_statusMessage);
1588
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1590
axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1592
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1595
AXIS2_FREE(env->allocator,start_input_str);
1596
AXIS2_FREE(env->allocator,end_input_str);
1600
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1602
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1603
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1604
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1606
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1607
"http://eucalyptus.ucsb.edu/",
1598
1612
if (!_ncAttachVolumeType->is_valid_instanceId)
1601
1615
/* no need to complain for minoccurs=0 element */
1607
1621
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1608
(4 + axutil_strlen(p_prefix) +
1609
axutil_strlen("instanceId")));
1622
(4 + axutil_strlen(p_prefix) +
1623
axutil_strlen("instanceId")));
1611
1625
/* axutil_strlen("<:>") + 1 = 4 */
1612
1626
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1613
1627
(5 + axutil_strlen(p_prefix) + axutil_strlen("instanceId")));
1614
1628
/* axutil_strlen("</:>") + 1 = 5 */
1622
1636
* parsing instanceId element
1627
1641
sprintf(start_input_str, "<%s%sinstanceId>",
1628
1642
p_prefix?p_prefix:"",
1629
1643
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1631
1645
start_input_str_len = axutil_strlen(start_input_str);
1632
1646
sprintf(end_input_str, "</%s%sinstanceId>",
1633
1647
p_prefix?p_prefix:"",
1634
1648
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1635
1649
end_input_str_len = axutil_strlen(end_input_str);
1637
1651
text_value_6 = _ncAttachVolumeType->property_instanceId;
1639
1653
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1642
1656
text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1643
1657
if (text_value_6_temp)
1650
1664
axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1653
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1656
AXIS2_FREE(env->allocator,start_input_str);
1657
AXIS2_FREE(env->allocator,end_input_str);
1661
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1663
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1664
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1665
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1667
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1668
"http://eucalyptus.ucsb.edu/",
1667
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1670
AXIS2_FREE(env->allocator,start_input_str);
1671
AXIS2_FREE(env->allocator,end_input_str);
1675
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1677
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1678
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1679
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1681
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1682
"http://eucalyptus.ucsb.edu/",
1687
if (!_ncAttachVolumeType->is_valid_volumeId)
1690
/* no need to complain for minoccurs=0 element */
1696
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1697
(4 + axutil_strlen(p_prefix) +
1698
axutil_strlen("volumeId")));
1700
/* axutil_strlen("<:>") + 1 = 4 */
1701
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1702
(5 + axutil_strlen(p_prefix) + axutil_strlen("volumeId")));
1703
/* axutil_strlen("</:>") + 1 = 5 */
1711
* parsing volumeId element
1716
sprintf(start_input_str, "<%s%svolumeId>",
1717
p_prefix?p_prefix:"",
1718
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1720
start_input_str_len = axutil_strlen(start_input_str);
1721
sprintf(end_input_str, "</%s%svolumeId>",
1722
p_prefix?p_prefix:"",
1723
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1724
end_input_str_len = axutil_strlen(end_input_str);
1726
text_value_7 = _ncAttachVolumeType->property_volumeId;
1728
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1731
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1732
if (text_value_7_temp)
1734
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
1735
AXIS2_FREE(env->allocator, text_value_7_temp);
1739
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1742
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1745
AXIS2_FREE(env->allocator,start_input_str);
1746
AXIS2_FREE(env->allocator,end_input_str);
1750
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1752
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1753
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1754
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1756
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1757
"http://eucalyptus.ucsb.edu/",
1673
1762
if (!_ncAttachVolumeType->is_valid_remoteDev)
1676
1765
/* no need to complain for minoccurs=0 element */
1682
1771
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1683
(4 + axutil_strlen(p_prefix) +
1684
axutil_strlen("remoteDev")));
1772
(4 + axutil_strlen(p_prefix) +
1773
axutil_strlen("remoteDev")));
1686
1775
/* axutil_strlen("<:>") + 1 = 4 */
1687
1776
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1688
1777
(5 + axutil_strlen(p_prefix) + axutil_strlen("remoteDev")));
1689
1778
/* axutil_strlen("</:>") + 1 = 5 */
1697
1786
* parsing remoteDev element
1702
1791
sprintf(start_input_str, "<%s%sremoteDev>",
1703
1792
p_prefix?p_prefix:"",
1704
1793
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1706
1795
start_input_str_len = axutil_strlen(start_input_str);
1707
1796
sprintf(end_input_str, "</%s%sremoteDev>",
1708
1797
p_prefix?p_prefix:"",
1709
1798
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1710
1799
end_input_str_len = axutil_strlen(end_input_str);
1712
text_value_7 = _ncAttachVolumeType->property_remoteDev;
1801
text_value_8 = _ncAttachVolumeType->property_remoteDev;
1714
1803
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1717
text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1718
if (text_value_7_temp)
1806
text_value_8_temp = axutil_xml_quote_string(env, text_value_8, AXIS2_TRUE);
1807
if (text_value_8_temp)
1720
axutil_stream_write(stream, env, text_value_7_temp, axutil_strlen(text_value_7_temp));
1721
AXIS2_FREE(env->allocator, text_value_7_temp);
1809
axutil_stream_write(stream, env, text_value_8_temp, axutil_strlen(text_value_8_temp));
1810
AXIS2_FREE(env->allocator, text_value_8_temp);
1725
axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1814
axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
1728
1817
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1731
1820
AXIS2_FREE(env->allocator,start_input_str);
1732
1821
AXIS2_FREE(env->allocator,end_input_str);
1736
1825
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1738
1827
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1739
1828
sprintf(p_prefix, "n%d", (*next_ns_index)++);
1740
1829
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1742
1831
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1743
1832
"http://eucalyptus.ucsb.edu/",
1748
1837
if (!_ncAttachVolumeType->is_valid_localDev)
1751
1840
/* no need to complain for minoccurs=0 element */
1757
1846
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1758
(4 + axutil_strlen(p_prefix) +
1759
axutil_strlen("localDev")));
1847
(4 + axutil_strlen(p_prefix) +
1848
axutil_strlen("localDev")));
1761
1850
/* axutil_strlen("<:>") + 1 = 4 */
1762
1851
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1763
1852
(5 + axutil_strlen(p_prefix) + axutil_strlen("localDev")));
1764
1853
/* axutil_strlen("</:>") + 1 = 5 */
1772
1861
* parsing localDev element
1777
1866
sprintf(start_input_str, "<%s%slocalDev>",
1778
1867
p_prefix?p_prefix:"",
1779
1868
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1781
1870
start_input_str_len = axutil_strlen(start_input_str);
1782
1871
sprintf(end_input_str, "</%s%slocalDev>",
1783
1872
p_prefix?p_prefix:"",
1784
1873
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1785
1874
end_input_str_len = axutil_strlen(end_input_str);
1787
text_value_8 = _ncAttachVolumeType->property_localDev;
1876
text_value_9 = _ncAttachVolumeType->property_localDev;
1789
1878
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1792
text_value_8_temp = axutil_xml_quote_string(env, text_value_8, AXIS2_TRUE);
1793
if (text_value_8_temp)
1881
text_value_9_temp = axutil_xml_quote_string(env, text_value_9, AXIS2_TRUE);
1882
if (text_value_9_temp)
1795
axutil_stream_write(stream, env, text_value_8_temp, axutil_strlen(text_value_8_temp));
1796
AXIS2_FREE(env->allocator, text_value_8_temp);
1884
axutil_stream_write(stream, env, text_value_9_temp, axutil_strlen(text_value_9_temp));
1885
AXIS2_FREE(env->allocator, text_value_9_temp);
1800
axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
1889
axutil_stream_write(stream, env, text_value_9, axutil_strlen(text_value_9));
1803
1892
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1806
1895
AXIS2_FREE(env->allocator,start_input_str);
1807
1896
AXIS2_FREE(env->allocator,end_input_str);
1819
1908
* getter for correlationId.
2143
2232
return adb_ncAttachVolumeType_reset_return(_ncAttachVolumeType, env);
2238
* getter for nodeName.
2240
axis2_char_t* AXIS2_CALL
2241
adb_ncAttachVolumeType_get_nodeName(
2242
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2243
const axutil_env_t *env)
2246
AXIS2_ENV_CHECK(env, NULL);
2247
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2250
return _ncAttachVolumeType->property_nodeName;
2254
* setter for nodeName
2256
axis2_status_t AXIS2_CALL
2257
adb_ncAttachVolumeType_set_nodeName(
2258
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2259
const axutil_env_t *env,
2260
const axis2_char_t* arg_nodeName)
2264
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2265
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2267
if(_ncAttachVolumeType->is_valid_nodeName &&
2268
arg_nodeName == _ncAttachVolumeType->property_nodeName)
2271
return AXIS2_SUCCESS;
2274
adb_ncAttachVolumeType_reset_nodeName(_ncAttachVolumeType, env);
2277
if(NULL == arg_nodeName)
2279
/* We are already done */
2280
return AXIS2_SUCCESS;
2282
_ncAttachVolumeType->property_nodeName = (axis2_char_t *)axutil_strdup(env, arg_nodeName);
2283
if(NULL == _ncAttachVolumeType->property_nodeName)
2285
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeName");
2286
return AXIS2_FAILURE;
2288
_ncAttachVolumeType->is_valid_nodeName = AXIS2_TRUE;
2290
return AXIS2_SUCCESS;
2296
* resetter for nodeName
2298
axis2_status_t AXIS2_CALL
2299
adb_ncAttachVolumeType_reset_nodeName(
2300
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2301
const axutil_env_t *env)
2305
void *element = NULL;
2307
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2308
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2314
if(_ncAttachVolumeType->property_nodeName != NULL)
2318
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_nodeName);
2319
_ncAttachVolumeType->property_nodeName = NULL;
2324
_ncAttachVolumeType->is_valid_nodeName = AXIS2_FALSE;
2325
return AXIS2_SUCCESS;
2329
* Check whether nodeName is nill
2331
axis2_bool_t AXIS2_CALL
2332
adb_ncAttachVolumeType_is_nodeName_nil(
2333
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2334
const axutil_env_t *env)
2336
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2337
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2339
return !_ncAttachVolumeType->is_valid_nodeName;
2343
* Set nodeName to nill (currently the same as reset)
2345
axis2_status_t AXIS2_CALL
2346
adb_ncAttachVolumeType_set_nodeName_nil(
2347
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2348
const axutil_env_t *env)
2350
return adb_ncAttachVolumeType_reset_nodeName(_ncAttachVolumeType, env);
2149
2356
* getter for statusMessage.
2237
2444
return adb_ncAttachVolumeType_reset_statusMessage(_ncAttachVolumeType, env);
2450
* getter for instanceId.
2452
axis2_char_t* AXIS2_CALL
2453
adb_ncAttachVolumeType_get_instanceId(
2454
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2455
const axutil_env_t *env)
2458
AXIS2_ENV_CHECK(env, NULL);
2459
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2462
return _ncAttachVolumeType->property_instanceId;
2466
* setter for instanceId
2468
axis2_status_t AXIS2_CALL
2469
adb_ncAttachVolumeType_set_instanceId(
2470
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2471
const axutil_env_t *env,
2472
const axis2_char_t* arg_instanceId)
2476
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2477
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2479
if(_ncAttachVolumeType->is_valid_instanceId &&
2480
arg_instanceId == _ncAttachVolumeType->property_instanceId)
2483
return AXIS2_SUCCESS;
2486
adb_ncAttachVolumeType_reset_instanceId(_ncAttachVolumeType, env);
2489
if(NULL == arg_instanceId)
2491
/* We are already done */
2492
return AXIS2_SUCCESS;
2494
_ncAttachVolumeType->property_instanceId = (axis2_char_t *)axutil_strdup(env, arg_instanceId);
2495
if(NULL == _ncAttachVolumeType->property_instanceId)
2497
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for instanceId");
2498
return AXIS2_FAILURE;
2500
_ncAttachVolumeType->is_valid_instanceId = AXIS2_TRUE;
2502
return AXIS2_SUCCESS;
2508
* resetter for instanceId
2510
axis2_status_t AXIS2_CALL
2511
adb_ncAttachVolumeType_reset_instanceId(
2512
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2513
const axutil_env_t *env)
2517
void *element = NULL;
2519
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2520
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2526
if(_ncAttachVolumeType->property_instanceId != NULL)
2530
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_instanceId);
2531
_ncAttachVolumeType->property_instanceId = NULL;
2536
_ncAttachVolumeType->is_valid_instanceId = AXIS2_FALSE;
2537
return AXIS2_SUCCESS;
2541
* Check whether instanceId is nill
2543
axis2_bool_t AXIS2_CALL
2544
adb_ncAttachVolumeType_is_instanceId_nil(
2545
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2546
const axutil_env_t *env)
2548
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2549
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2551
return !_ncAttachVolumeType->is_valid_instanceId;
2555
* Set instanceId to nill (currently the same as reset)
2557
axis2_status_t AXIS2_CALL
2558
adb_ncAttachVolumeType_set_instanceId_nil(
2559
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2560
const axutil_env_t *env)
2562
return adb_ncAttachVolumeType_reset_instanceId(_ncAttachVolumeType, env);
2243
2568
* getter for volumeId.
2355
2680
return adb_ncAttachVolumeType_reset_volumeId(_ncAttachVolumeType, env);
2361
* getter for instanceId.
2363
axis2_char_t* AXIS2_CALL
2364
adb_ncAttachVolumeType_get_instanceId(
2365
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2366
const axutil_env_t *env)
2369
AXIS2_ENV_CHECK(env, NULL);
2370
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, NULL);
2373
return _ncAttachVolumeType->property_instanceId;
2377
* setter for instanceId
2379
axis2_status_t AXIS2_CALL
2380
adb_ncAttachVolumeType_set_instanceId(
2381
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2382
const axutil_env_t *env,
2383
const axis2_char_t* arg_instanceId)
2387
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2388
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2390
if(_ncAttachVolumeType->is_valid_instanceId &&
2391
arg_instanceId == _ncAttachVolumeType->property_instanceId)
2394
return AXIS2_SUCCESS;
2397
adb_ncAttachVolumeType_reset_instanceId(_ncAttachVolumeType, env);
2400
if(NULL == arg_instanceId)
2402
/* We are already done */
2403
return AXIS2_SUCCESS;
2405
_ncAttachVolumeType->property_instanceId = (axis2_char_t *)axutil_strdup(env, arg_instanceId);
2406
if(NULL == _ncAttachVolumeType->property_instanceId)
2408
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for instanceId");
2409
return AXIS2_FAILURE;
2411
_ncAttachVolumeType->is_valid_instanceId = AXIS2_TRUE;
2413
return AXIS2_SUCCESS;
2419
* resetter for instanceId
2421
axis2_status_t AXIS2_CALL
2422
adb_ncAttachVolumeType_reset_instanceId(
2423
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2424
const axutil_env_t *env)
2428
void *element = NULL;
2430
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2431
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_FAILURE);
2437
if(_ncAttachVolumeType->property_instanceId != NULL)
2441
AXIS2_FREE(env-> allocator, _ncAttachVolumeType->property_instanceId);
2442
_ncAttachVolumeType->property_instanceId = NULL;
2447
_ncAttachVolumeType->is_valid_instanceId = AXIS2_FALSE;
2448
return AXIS2_SUCCESS;
2452
* Check whether instanceId is nill
2454
axis2_bool_t AXIS2_CALL
2455
adb_ncAttachVolumeType_is_instanceId_nil(
2456
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2457
const axutil_env_t *env)
2459
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2460
AXIS2_PARAM_CHECK(env->error, _ncAttachVolumeType, AXIS2_TRUE);
2462
return !_ncAttachVolumeType->is_valid_instanceId;
2466
* Set instanceId to nill (currently the same as reset)
2468
axis2_status_t AXIS2_CALL
2469
adb_ncAttachVolumeType_set_instanceId_nil(
2470
adb_ncAttachVolumeType_t* _ncAttachVolumeType,
2471
const axutil_env_t *env)
2473
return adb_ncAttachVolumeType_reset_instanceId(_ncAttachVolumeType, env);
2479
2686
* getter for remoteDev.
added
removed
cluster/generated/adb_ncAttachVolumeType.c
