4
* adb_virtualMachineType.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_virtualMachineType.h"
13
* This type was generated from the piece of schema that had
14
* name = virtualMachineType
15
* Namespace URI = http://eucalyptus.ucsb.edu/
16
* Namespace Prefix = ns1
21
struct adb_virtualMachineType
26
axis2_bool_t is_valid_memory;
32
axis2_bool_t is_valid_cores;
38
axis2_bool_t is_valid_disk;
45
/************************* Private Function prototypes ********************************/
48
axis2_status_t AXIS2_CALL
49
adb_virtualMachineType_set_memory_nil(
50
adb_virtualMachineType_t* _virtualMachineType,
51
const axutil_env_t *env);
54
axis2_status_t AXIS2_CALL
55
adb_virtualMachineType_set_cores_nil(
56
adb_virtualMachineType_t* _virtualMachineType,
57
const axutil_env_t *env);
60
axis2_status_t AXIS2_CALL
61
adb_virtualMachineType_set_disk_nil(
62
adb_virtualMachineType_t* _virtualMachineType,
63
const axutil_env_t *env);
67
/************************* Function Implmentations ********************************/
68
adb_virtualMachineType_t* AXIS2_CALL
69
adb_virtualMachineType_create(
70
const axutil_env_t *env)
72
adb_virtualMachineType_t *_virtualMachineType = NULL;
74
AXIS2_ENV_CHECK(env, NULL);
76
_virtualMachineType = (adb_virtualMachineType_t *) AXIS2_MALLOC(env->
77
allocator, sizeof(adb_virtualMachineType_t));
79
if(NULL == _virtualMachineType)
81
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
85
memset(_virtualMachineType, 0, sizeof(adb_virtualMachineType_t));
87
_virtualMachineType->is_valid_memory = AXIS2_FALSE;
88
_virtualMachineType->is_valid_cores = AXIS2_FALSE;
89
_virtualMachineType->is_valid_disk = AXIS2_FALSE;
92
return _virtualMachineType;
95
axis2_status_t AXIS2_CALL
96
adb_virtualMachineType_free (
97
adb_virtualMachineType_t* _virtualMachineType,
98
const axutil_env_t *env)
102
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
103
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
105
adb_virtualMachineType_reset_memory(_virtualMachineType, env);
106
adb_virtualMachineType_reset_cores(_virtualMachineType, env);
107
adb_virtualMachineType_reset_disk(_virtualMachineType, env);
110
if(_virtualMachineType)
112
AXIS2_FREE(env->allocator, _virtualMachineType);
113
_virtualMachineType = NULL;
115
return AXIS2_SUCCESS;
121
axis2_status_t AXIS2_CALL
122
adb_virtualMachineType_deserialize(
123
adb_virtualMachineType_t* _virtualMachineType,
124
const axutil_env_t *env,
125
axiom_node_t **dp_parent,
126
axis2_bool_t *dp_is_early_node_valid,
127
axis2_bool_t dont_care_minoccurs)
129
axiom_node_t *parent = *dp_parent;
131
axis2_status_t status = AXIS2_SUCCESS;
133
axis2_char_t* text_value = NULL;
134
axutil_qname_t *qname = NULL;
136
axutil_qname_t *element_qname = NULL;
138
axiom_node_t *first_node = NULL;
139
axis2_bool_t is_early_node_valid = AXIS2_TRUE;
140
axiom_node_t *current_node = NULL;
141
axiom_element_t *current_element = NULL;
143
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
144
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
148
while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
150
parent = axiom_node_get_next_sibling(parent, env);
154
/* This should be checked before everything */
155
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
156
"Failed in building adb object for virtualMachineType : "
157
"NULL elemenet can not be passed to deserialize");
158
return AXIS2_FAILURE;
162
first_node = axiom_node_get_first_child(parent, env);
168
* building memory element
173
current_node = first_node;
174
is_early_node_valid = AXIS2_FALSE;
177
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
179
current_node = axiom_node_get_next_sibling(current_node, env);
181
if(current_node != NULL)
183
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
184
qname = axiom_element_get_qname(current_element, env, current_node);
187
element_qname = axutil_qname_create(env, "memory", "http://eucalyptus.ucsb.edu/", NULL);
191
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
193
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
195
is_early_node_valid = AXIS2_TRUE;
199
text_value = axiom_element_get_text(current_element, env, current_node);
200
if(text_value != NULL)
202
status = adb_virtualMachineType_set_memory(_virtualMachineType, env,
208
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element memory");
209
status = AXIS2_FAILURE;
212
if(AXIS2_FAILURE == status)
214
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for memory ");
217
axutil_qname_free(element_qname, env);
219
return AXIS2_FAILURE;
225
axutil_qname_free(element_qname, env);
226
element_qname = NULL;
232
* building cores element
238
* because elements are ordered this works fine
242
if(current_node != NULL && is_early_node_valid)
244
current_node = axiom_node_get_next_sibling(current_node, env);
247
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
249
current_node = axiom_node_get_next_sibling(current_node, env);
251
if(current_node != NULL)
253
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
254
qname = axiom_element_get_qname(current_element, env, current_node);
258
is_early_node_valid = AXIS2_FALSE;
260
element_qname = axutil_qname_create(env, "cores", "http://eucalyptus.ucsb.edu/", NULL);
264
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
266
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
268
is_early_node_valid = AXIS2_TRUE;
272
text_value = axiom_element_get_text(current_element, env, current_node);
273
if(text_value != NULL)
275
status = adb_virtualMachineType_set_cores(_virtualMachineType, env,
281
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element cores");
282
status = AXIS2_FAILURE;
285
if(AXIS2_FAILURE == status)
287
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for cores ");
290
axutil_qname_free(element_qname, env);
292
return AXIS2_FAILURE;
298
axutil_qname_free(element_qname, env);
299
element_qname = NULL;
305
* building disk element
311
* because elements are ordered this works fine
315
if(current_node != NULL && is_early_node_valid)
317
current_node = axiom_node_get_next_sibling(current_node, env);
320
while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
322
current_node = axiom_node_get_next_sibling(current_node, env);
324
if(current_node != NULL)
326
current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
327
qname = axiom_element_get_qname(current_element, env, current_node);
331
is_early_node_valid = AXIS2_FALSE;
333
element_qname = axutil_qname_create(env, "disk", "http://eucalyptus.ucsb.edu/", NULL);
337
(current_node && current_element && (axutil_qname_equals(element_qname, env, qname))))
339
if( current_node && current_element && (axutil_qname_equals(element_qname, env, qname)))
341
is_early_node_valid = AXIS2_TRUE;
345
text_value = axiom_element_get_text(current_element, env, current_node);
346
if(text_value != NULL)
348
status = adb_virtualMachineType_set_disk(_virtualMachineType, env,
354
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element disk");
355
status = AXIS2_FAILURE;
358
if(AXIS2_FAILURE == status)
360
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for disk ");
363
axutil_qname_free(element_qname, env);
365
return AXIS2_FAILURE;
371
axutil_qname_free(element_qname, env);
372
element_qname = NULL;
378
axis2_bool_t AXIS2_CALL
379
adb_virtualMachineType_is_particle()
388
adb_virtualMachineType_declare_parent_namespaces(
389
adb_virtualMachineType_t* _virtualMachineType,
390
const axutil_env_t *env, axiom_element_t *parent_element,
391
axutil_hash_t *namespaces, int *next_ns_index)
394
/* Here this is an empty function, Nothing to declare */
400
axiom_node_t* AXIS2_CALL
401
adb_virtualMachineType_serialize(
402
adb_virtualMachineType_t* _virtualMachineType,
403
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)
407
axis2_char_t *string_to_stream;
410
axiom_node_t *current_node = NULL;
415
axiom_namespace_t *ns1 = NULL;
417
axis2_char_t *qname_uri = NULL;
418
axis2_char_t *qname_prefix = NULL;
419
axis2_char_t *p_prefix = NULL;
420
axis2_bool_t ns_already_defined;
422
axis2_char_t text_value_1[64];
424
axis2_char_t text_value_2[64];
426
axis2_char_t text_value_3[64];
428
axis2_char_t *start_input_str = NULL;
429
axis2_char_t *end_input_str = NULL;
430
unsigned int start_input_str_len = 0;
431
unsigned int end_input_str_len = 0;
434
axiom_data_source_t *data_source = NULL;
435
axutil_stream_t *stream = NULL;
439
AXIS2_ENV_CHECK(env, NULL);
440
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, NULL);
443
current_node = parent;
444
data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
447
stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
451
if(!parent_tag_closed)
454
string_to_stream = ">";
455
axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
460
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
462
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
463
sprintf(p_prefix, "n%d", (*next_ns_index)++);
464
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
466
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
467
"http://eucalyptus.ucsb.edu/",
472
if (!_virtualMachineType->is_valid_memory)
475
/* no need to complain for minoccurs=0 element */
481
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
482
(4 + axutil_strlen(p_prefix) +
483
axutil_strlen("memory")));
485
/* axutil_strlen("<:>") + 1 = 4 */
486
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
487
(5 + axutil_strlen(p_prefix) + axutil_strlen("memory")));
488
/* axutil_strlen("</:>") + 1 = 5 */
496
* parsing memory element
501
sprintf(start_input_str, "<%s%smemory>",
502
p_prefix?p_prefix:"",
503
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
505
start_input_str_len = axutil_strlen(start_input_str);
506
sprintf(end_input_str, "</%s%smemory>",
507
p_prefix?p_prefix:"",
508
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
509
end_input_str_len = axutil_strlen(end_input_str);
511
sprintf (text_value_1, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _virtualMachineType->property_memory);
513
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
515
axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
517
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
520
AXIS2_FREE(env->allocator,start_input_str);
521
AXIS2_FREE(env->allocator,end_input_str);
525
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
527
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
528
sprintf(p_prefix, "n%d", (*next_ns_index)++);
529
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
531
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
532
"http://eucalyptus.ucsb.edu/",
537
if (!_virtualMachineType->is_valid_cores)
540
/* no need to complain for minoccurs=0 element */
546
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
547
(4 + axutil_strlen(p_prefix) +
548
axutil_strlen("cores")));
550
/* axutil_strlen("<:>") + 1 = 4 */
551
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
552
(5 + axutil_strlen(p_prefix) + axutil_strlen("cores")));
553
/* axutil_strlen("</:>") + 1 = 5 */
561
* parsing cores element
566
sprintf(start_input_str, "<%s%scores>",
567
p_prefix?p_prefix:"",
568
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
570
start_input_str_len = axutil_strlen(start_input_str);
571
sprintf(end_input_str, "</%s%scores>",
572
p_prefix?p_prefix:"",
573
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
574
end_input_str_len = axutil_strlen(end_input_str);
576
sprintf (text_value_2, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _virtualMachineType->property_cores);
578
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
580
axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
582
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
585
AXIS2_FREE(env->allocator,start_input_str);
586
AXIS2_FREE(env->allocator,end_input_str);
590
if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
592
p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
593
sprintf(p_prefix, "n%d", (*next_ns_index)++);
594
axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
596
axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
597
"http://eucalyptus.ucsb.edu/",
602
if (!_virtualMachineType->is_valid_disk)
605
/* no need to complain for minoccurs=0 element */
611
start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
612
(4 + axutil_strlen(p_prefix) +
613
axutil_strlen("disk")));
615
/* axutil_strlen("<:>") + 1 = 4 */
616
end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
617
(5 + axutil_strlen(p_prefix) + axutil_strlen("disk")));
618
/* axutil_strlen("</:>") + 1 = 5 */
626
* parsing disk element
631
sprintf(start_input_str, "<%s%sdisk>",
632
p_prefix?p_prefix:"",
633
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
635
start_input_str_len = axutil_strlen(start_input_str);
636
sprintf(end_input_str, "</%s%sdisk>",
637
p_prefix?p_prefix:"",
638
(p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
639
end_input_str_len = axutil_strlen(end_input_str);
641
sprintf (text_value_3, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _virtualMachineType->property_disk);
643
axutil_stream_write(stream, env, start_input_str, start_input_str_len);
645
axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
647
axutil_stream_write(stream, env, end_input_str, end_input_str_len);
650
AXIS2_FREE(env->allocator,start_input_str);
651
AXIS2_FREE(env->allocator,end_input_str);
666
adb_virtualMachineType_get_memory(
667
adb_virtualMachineType_t* _virtualMachineType,
668
const axutil_env_t *env)
671
AXIS2_ENV_CHECK(env, (int)0);
672
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, (int)0);
675
return _virtualMachineType->property_memory;
681
axis2_status_t AXIS2_CALL
682
adb_virtualMachineType_set_memory(
683
adb_virtualMachineType_t* _virtualMachineType,
684
const axutil_env_t *env,
685
const int arg_memory)
689
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
690
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
692
if(_virtualMachineType->is_valid_memory &&
693
arg_memory == _virtualMachineType->property_memory)
696
return AXIS2_SUCCESS;
699
adb_virtualMachineType_reset_memory(_virtualMachineType, env);
701
_virtualMachineType->property_memory = arg_memory;
702
_virtualMachineType->is_valid_memory = AXIS2_TRUE;
704
return AXIS2_SUCCESS;
710
* resetter for memory
712
axis2_status_t AXIS2_CALL
713
adb_virtualMachineType_reset_memory(
714
adb_virtualMachineType_t* _virtualMachineType,
715
const axutil_env_t *env)
719
void *element = NULL;
721
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
722
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
725
_virtualMachineType->is_valid_memory = AXIS2_FALSE;
726
return AXIS2_SUCCESS;
730
* Check whether memory is nill
732
axis2_bool_t AXIS2_CALL
733
adb_virtualMachineType_is_memory_nil(
734
adb_virtualMachineType_t* _virtualMachineType,
735
const axutil_env_t *env)
737
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
738
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_TRUE);
740
return !_virtualMachineType->is_valid_memory;
744
* Set memory to nill (currently the same as reset)
746
axis2_status_t AXIS2_CALL
747
adb_virtualMachineType_set_memory_nil(
748
adb_virtualMachineType_t* _virtualMachineType,
749
const axutil_env_t *env)
751
return adb_virtualMachineType_reset_memory(_virtualMachineType, env);
760
adb_virtualMachineType_get_cores(
761
adb_virtualMachineType_t* _virtualMachineType,
762
const axutil_env_t *env)
765
AXIS2_ENV_CHECK(env, (int)0);
766
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, (int)0);
769
return _virtualMachineType->property_cores;
775
axis2_status_t AXIS2_CALL
776
adb_virtualMachineType_set_cores(
777
adb_virtualMachineType_t* _virtualMachineType,
778
const axutil_env_t *env,
783
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
784
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
786
if(_virtualMachineType->is_valid_cores &&
787
arg_cores == _virtualMachineType->property_cores)
790
return AXIS2_SUCCESS;
793
adb_virtualMachineType_reset_cores(_virtualMachineType, env);
795
_virtualMachineType->property_cores = arg_cores;
796
_virtualMachineType->is_valid_cores = AXIS2_TRUE;
798
return AXIS2_SUCCESS;
806
axis2_status_t AXIS2_CALL
807
adb_virtualMachineType_reset_cores(
808
adb_virtualMachineType_t* _virtualMachineType,
809
const axutil_env_t *env)
813
void *element = NULL;
815
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
816
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
819
_virtualMachineType->is_valid_cores = AXIS2_FALSE;
820
return AXIS2_SUCCESS;
824
* Check whether cores is nill
826
axis2_bool_t AXIS2_CALL
827
adb_virtualMachineType_is_cores_nil(
828
adb_virtualMachineType_t* _virtualMachineType,
829
const axutil_env_t *env)
831
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
832
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_TRUE);
834
return !_virtualMachineType->is_valid_cores;
838
* Set cores to nill (currently the same as reset)
840
axis2_status_t AXIS2_CALL
841
adb_virtualMachineType_set_cores_nil(
842
adb_virtualMachineType_t* _virtualMachineType,
843
const axutil_env_t *env)
845
return adb_virtualMachineType_reset_cores(_virtualMachineType, env);
854
adb_virtualMachineType_get_disk(
855
adb_virtualMachineType_t* _virtualMachineType,
856
const axutil_env_t *env)
859
AXIS2_ENV_CHECK(env, (int)0);
860
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, (int)0);
863
return _virtualMachineType->property_disk;
869
axis2_status_t AXIS2_CALL
870
adb_virtualMachineType_set_disk(
871
adb_virtualMachineType_t* _virtualMachineType,
872
const axutil_env_t *env,
877
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
878
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
880
if(_virtualMachineType->is_valid_disk &&
881
arg_disk == _virtualMachineType->property_disk)
884
return AXIS2_SUCCESS;
887
adb_virtualMachineType_reset_disk(_virtualMachineType, env);
889
_virtualMachineType->property_disk = arg_disk;
890
_virtualMachineType->is_valid_disk = AXIS2_TRUE;
892
return AXIS2_SUCCESS;
900
axis2_status_t AXIS2_CALL
901
adb_virtualMachineType_reset_disk(
902
adb_virtualMachineType_t* _virtualMachineType,
903
const axutil_env_t *env)
907
void *element = NULL;
909
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
910
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_FAILURE);
913
_virtualMachineType->is_valid_disk = AXIS2_FALSE;
914
return AXIS2_SUCCESS;
918
* Check whether disk is nill
920
axis2_bool_t AXIS2_CALL
921
adb_virtualMachineType_is_disk_nil(
922
adb_virtualMachineType_t* _virtualMachineType,
923
const axutil_env_t *env)
925
AXIS2_ENV_CHECK(env, AXIS2_TRUE);
926
AXIS2_PARAM_CHECK(env->error, _virtualMachineType, AXIS2_TRUE);
928
return !_virtualMachineType->is_valid_disk;
932
* Set disk to nill (currently the same as reset)
934
axis2_status_t AXIS2_CALL
935
adb_virtualMachineType_set_disk_nil(
936
adb_virtualMachineType_t* _virtualMachineType,
937
const axutil_env_t *env)
939
return adb_virtualMachineType_reset_disk(_virtualMachineType, env);