← Back to branch summary

~ubuntu-core-dev/ubuntu/maverick/eucalyptus/devel

« back to all changes in this revision

Viewing changes to cluster/generated/adb_attachVolumeType.h

  • Committer: Dustin Kirkland
  • Date: 2010-07-22 08:41:57 UTC
  • mfrom: (1050.1.19 ubuntu)
  • Revision ID: kirkland@x200-20100722084157-zh2p8dkawznvxxpn
Approving Dave Walker's merge of new upstream Eucalyptus 2.0 release.

Dustin Kirkland <kirkland@canonical.com>

* New major upstream version merge, 2.0 (r1211).
  - 01-wsdl-stubs.patch, debian/wsdl.md5sums: wsdl stubs updated.
  - 11-state-cleanup-memleakfix.patch: Removed, fixed upstream.
  - 21-eucalyptus-1.7-with-gwt-1.6.4.patch: New patch, allows 
    eucalyptus-1.7 to be built against gwt 1.6.4. Based on patch courtesy 
    of Dmitrii Zagorodnov, upstream. (LP: #597330)
* debian/eucalyptus-java-common.links: 
  - Changed symlink for groovy, point to groovy.all.jar, making compatiable 
    with groovy versions >1.7. (LP: #595421)
  - Added ant.jar & jetty-rewrite-handler.jar as they are now required.
* debian/control
  - & debian/build-jars: Added libjavassist-java and libjetty-extra-java as 
    build dependencies.
  - Added libjetty-extra-java as a dependency of eucalyptus-java-common
* The binary resulting jar's have been renamed from eucalyptus-*-1.6.2.jar
  to eucalyptus-*-main.jar:    
  - debian/eucalyptus-cc.upstart
  - debian/eucalyptus-cloud.install
  - debian/eucalyptus-common.eucalyptus.upstart
  - debian/eucalyptus-java-common.install
  - debian/eucalyptus-network.upstart
  - debian/eucalyptus-sc.install
  - debian/eucalyptus-walrus.install
* debian/eucalyptus-java-common.install: New upstream jars that have been
  installed:
  - eucalyptus-db-hsqldb-ext-main.jar
  - eucalyptus-component-main.jar
* debian/control:
  - Updated Standards Version to 3.8.4 (no change)
  - Updated the upstream Homepage to: http://open.eucalyptus.com/
  - Changed Vcs-Bzr to reflect new location of Ubuntu hosted development branch.
  - Made the Build Dependency of groovy and the binary eucalyptus-java-common
    package depend on version >=1.7.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cluster/generated/adb_attachVolumeType.h
 
1
 
 
2
 
 
3
        #ifndef ADB_ATTACHVOLUMETYPE_H
 
4
        #define ADB_ATTACHVOLUMETYPE_H
 
5
 
 
6
       /**
 
7
        * adb_attachVolumeType.h
 
8
        *
 
9
        * This file was auto-generated from WSDL
 
10
        * by the Apache Axis2/Java version: 1.4  Built on : Apr 26, 2008 (06:25:17 EDT)
 
11
        */
 
12
 
 
13
       /**
 
14
        *  adb_attachVolumeType class
 
15
        */
 
16
        typedef struct adb_attachVolumeType adb_attachVolumeType_t;
 
17
 
 
18
        
 
19
 
 
20
        #include <stdio.h>
 
21
        #include <axiom.h>
 
22
        #include <axis2_util.h>
 
23
        #include <axiom_soap.h>
 
24
        #include <axis2_client.h>
 
25
 
 
26
        #ifdef __cplusplus
 
27
        extern "C"
 
28
        {
 
29
        #endif
 
30
 
 
31
        #define ADB_DEFAULT_DIGIT_LIMIT 64
 
32
        #define ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT 64
 
33
        
 
34
 
 
35
        /******************************* Create and Free functions *********************************/
 
36
 
 
37
        /**
 
38
         * Constructor for creating adb_attachVolumeType_t
 
39
         * @param env pointer to environment struct
 
40
         * @return newly created adb_attachVolumeType_t object
 
41
         */
 
42
        adb_attachVolumeType_t* AXIS2_CALL
 
43
        adb_attachVolumeType_create(
 
44
            const axutil_env_t *env );
 
45
 
 
46
        /**
 
47
         * Free adb_attachVolumeType_t object
 
48
         * @param  _attachVolumeType adb_attachVolumeType_t object to free
 
49
         * @param env pointer to environment struct
 
50
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
51
         */
 
52
        axis2_status_t AXIS2_CALL
 
53
        adb_attachVolumeType_free (
 
54
            adb_attachVolumeType_t* _attachVolumeType,
 
55
            const axutil_env_t *env);
 
56
 
 
57
 
 
58
 
 
59
        /********************************** Getters and Setters **************************************/
 
60
        
 
61
        
 
62
 
 
63
        /**
 
64
         * Getter for correlationId. 
 
65
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
66
         * @param env pointer to environment struct
 
67
         * @return axis2_char_t*
 
68
         */
 
69
        axis2_char_t* AXIS2_CALL
 
70
        adb_attachVolumeType_get_correlationId(
 
71
            adb_attachVolumeType_t* _attachVolumeType,
 
72
            const axutil_env_t *env);
 
73
 
 
74
        /**
 
75
         * Setter for correlationId.
 
76
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
77
         * @param env pointer to environment struct
 
78
         * @param arg_correlationId axis2_char_t*
 
79
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
80
         */
 
81
        axis2_status_t AXIS2_CALL
 
82
        adb_attachVolumeType_set_correlationId(
 
83
            adb_attachVolumeType_t* _attachVolumeType,
 
84
            const axutil_env_t *env,
 
85
            const axis2_char_t*  arg_correlationId);
 
86
 
 
87
        /**
 
88
         * Resetter for correlationId
 
89
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
90
         * @param env pointer to environment struct
 
91
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
92
         */
 
93
        axis2_status_t AXIS2_CALL
 
94
        adb_attachVolumeType_reset_correlationId(
 
95
            adb_attachVolumeType_t* _attachVolumeType,
 
96
            const axutil_env_t *env);
 
97
 
 
98
        
 
99
        
 
100
 
 
101
        /**
 
102
         * Getter for userId. 
 
103
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
104
         * @param env pointer to environment struct
 
105
         * @return axis2_char_t*
 
106
         */
 
107
        axis2_char_t* AXIS2_CALL
 
108
        adb_attachVolumeType_get_userId(
 
109
            adb_attachVolumeType_t* _attachVolumeType,
 
110
            const axutil_env_t *env);
 
111
 
 
112
        /**
 
113
         * Setter for userId.
 
114
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
115
         * @param env pointer to environment struct
 
116
         * @param arg_userId axis2_char_t*
 
117
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
118
         */
 
119
        axis2_status_t AXIS2_CALL
 
120
        adb_attachVolumeType_set_userId(
 
121
            adb_attachVolumeType_t* _attachVolumeType,
 
122
            const axutil_env_t *env,
 
123
            const axis2_char_t*  arg_userId);
 
124
 
 
125
        /**
 
126
         * Resetter for userId
 
127
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
128
         * @param env pointer to environment struct
 
129
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
130
         */
 
131
        axis2_status_t AXIS2_CALL
 
132
        adb_attachVolumeType_reset_userId(
 
133
            adb_attachVolumeType_t* _attachVolumeType,
 
134
            const axutil_env_t *env);
 
135
 
 
136
        
 
137
        
 
138
 
 
139
        /**
 
140
         * Getter for statusMessage. 
 
141
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
142
         * @param env pointer to environment struct
 
143
         * @return axis2_char_t*
 
144
         */
 
145
        axis2_char_t* AXIS2_CALL
 
146
        adb_attachVolumeType_get_statusMessage(
 
147
            adb_attachVolumeType_t* _attachVolumeType,
 
148
            const axutil_env_t *env);
 
149
 
 
150
        /**
 
151
         * Setter for statusMessage.
 
152
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
153
         * @param env pointer to environment struct
 
154
         * @param arg_statusMessage axis2_char_t*
 
155
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
156
         */
 
157
        axis2_status_t AXIS2_CALL
 
158
        adb_attachVolumeType_set_statusMessage(
 
159
            adb_attachVolumeType_t* _attachVolumeType,
 
160
            const axutil_env_t *env,
 
161
            const axis2_char_t*  arg_statusMessage);
 
162
 
 
163
        /**
 
164
         * Resetter for statusMessage
 
165
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
166
         * @param env pointer to environment struct
 
167
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
168
         */
 
169
        axis2_status_t AXIS2_CALL
 
170
        adb_attachVolumeType_reset_statusMessage(
 
171
            adb_attachVolumeType_t* _attachVolumeType,
 
172
            const axutil_env_t *env);
 
173
 
 
174
        
 
175
        
 
176
 
 
177
        /**
 
178
         * Getter for return. 
 
179
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
180
         * @param env pointer to environment struct
 
181
         * @return axis2_bool_t
 
182
         */
 
183
        axis2_bool_t AXIS2_CALL
 
184
        adb_attachVolumeType_get_return(
 
185
            adb_attachVolumeType_t* _attachVolumeType,
 
186
            const axutil_env_t *env);
 
187
 
 
188
        /**
 
189
         * Setter for return.
 
190
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
191
         * @param env pointer to environment struct
 
192
         * @param arg_return axis2_bool_t
 
193
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
194
         */
 
195
        axis2_status_t AXIS2_CALL
 
196
        adb_attachVolumeType_set_return(
 
197
            adb_attachVolumeType_t* _attachVolumeType,
 
198
            const axutil_env_t *env,
 
199
            axis2_bool_t  arg_return);
 
200
 
 
201
        /**
 
202
         * Resetter for return
 
203
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
204
         * @param env pointer to environment struct
 
205
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
206
         */
 
207
        axis2_status_t AXIS2_CALL
 
208
        adb_attachVolumeType_reset_return(
 
209
            adb_attachVolumeType_t* _attachVolumeType,
 
210
            const axutil_env_t *env);
 
211
 
 
212
        
 
213
        
 
214
 
 
215
        /**
 
216
         * Getter for volumeId. 
 
217
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
218
         * @param env pointer to environment struct
 
219
         * @return axis2_char_t*
 
220
         */
 
221
        axis2_char_t* AXIS2_CALL
 
222
        adb_attachVolumeType_get_volumeId(
 
223
            adb_attachVolumeType_t* _attachVolumeType,
 
224
            const axutil_env_t *env);
 
225
 
 
226
        /**
 
227
         * Setter for volumeId.
 
228
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
229
         * @param env pointer to environment struct
 
230
         * @param arg_volumeId axis2_char_t*
 
231
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
232
         */
 
233
        axis2_status_t AXIS2_CALL
 
234
        adb_attachVolumeType_set_volumeId(
 
235
            adb_attachVolumeType_t* _attachVolumeType,
 
236
            const axutil_env_t *env,
 
237
            const axis2_char_t*  arg_volumeId);
 
238
 
 
239
        /**
 
240
         * Resetter for volumeId
 
241
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
242
         * @param env pointer to environment struct
 
243
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
244
         */
 
245
        axis2_status_t AXIS2_CALL
 
246
        adb_attachVolumeType_reset_volumeId(
 
247
            adb_attachVolumeType_t* _attachVolumeType,
 
248
            const axutil_env_t *env);
 
249
 
 
250
        
 
251
        
 
252
 
 
253
        /**
 
254
         * Getter for instanceId. 
 
255
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
256
         * @param env pointer to environment struct
 
257
         * @return axis2_char_t*
 
258
         */
 
259
        axis2_char_t* AXIS2_CALL
 
260
        adb_attachVolumeType_get_instanceId(
 
261
            adb_attachVolumeType_t* _attachVolumeType,
 
262
            const axutil_env_t *env);
 
263
 
 
264
        /**
 
265
         * Setter for instanceId.
 
266
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
267
         * @param env pointer to environment struct
 
268
         * @param arg_instanceId axis2_char_t*
 
269
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
270
         */
 
271
        axis2_status_t AXIS2_CALL
 
272
        adb_attachVolumeType_set_instanceId(
 
273
            adb_attachVolumeType_t* _attachVolumeType,
 
274
            const axutil_env_t *env,
 
275
            const axis2_char_t*  arg_instanceId);
 
276
 
 
277
        /**
 
278
         * Resetter for instanceId
 
279
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
280
         * @param env pointer to environment struct
 
281
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
282
         */
 
283
        axis2_status_t AXIS2_CALL
 
284
        adb_attachVolumeType_reset_instanceId(
 
285
            adb_attachVolumeType_t* _attachVolumeType,
 
286
            const axutil_env_t *env);
 
287
 
 
288
        
 
289
        
 
290
 
 
291
        /**
 
292
         * Getter for remoteDev. 
 
293
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
294
         * @param env pointer to environment struct
 
295
         * @return axis2_char_t*
 
296
         */
 
297
        axis2_char_t* AXIS2_CALL
 
298
        adb_attachVolumeType_get_remoteDev(
 
299
            adb_attachVolumeType_t* _attachVolumeType,
 
300
            const axutil_env_t *env);
 
301
 
 
302
        /**
 
303
         * Setter for remoteDev.
 
304
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
305
         * @param env pointer to environment struct
 
306
         * @param arg_remoteDev axis2_char_t*
 
307
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
308
         */
 
309
        axis2_status_t AXIS2_CALL
 
310
        adb_attachVolumeType_set_remoteDev(
 
311
            adb_attachVolumeType_t* _attachVolumeType,
 
312
            const axutil_env_t *env,
 
313
            const axis2_char_t*  arg_remoteDev);
 
314
 
 
315
        /**
 
316
         * Resetter for remoteDev
 
317
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
318
         * @param env pointer to environment struct
 
319
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
320
         */
 
321
        axis2_status_t AXIS2_CALL
 
322
        adb_attachVolumeType_reset_remoteDev(
 
323
            adb_attachVolumeType_t* _attachVolumeType,
 
324
            const axutil_env_t *env);
 
325
 
 
326
        
 
327
        
 
328
 
 
329
        /**
 
330
         * Getter for localDev. 
 
331
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
332
         * @param env pointer to environment struct
 
333
         * @return axis2_char_t*
 
334
         */
 
335
        axis2_char_t* AXIS2_CALL
 
336
        adb_attachVolumeType_get_localDev(
 
337
            adb_attachVolumeType_t* _attachVolumeType,
 
338
            const axutil_env_t *env);
 
339
 
 
340
        /**
 
341
         * Setter for localDev.
 
342
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
343
         * @param env pointer to environment struct
 
344
         * @param arg_localDev axis2_char_t*
 
345
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
346
         */
 
347
        axis2_status_t AXIS2_CALL
 
348
        adb_attachVolumeType_set_localDev(
 
349
            adb_attachVolumeType_t* _attachVolumeType,
 
350
            const axutil_env_t *env,
 
351
            const axis2_char_t*  arg_localDev);
 
352
 
 
353
        /**
 
354
         * Resetter for localDev
 
355
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
356
         * @param env pointer to environment struct
 
357
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
358
         */
 
359
        axis2_status_t AXIS2_CALL
 
360
        adb_attachVolumeType_reset_localDev(
 
361
            adb_attachVolumeType_t* _attachVolumeType,
 
362
            const axutil_env_t *env);
 
363
 
 
364
        
 
365
 
 
366
 
 
367
        /******************************* Checking and Setting NIL values *********************************/
 
368
        
 
369
 
 
370
        /**
 
371
         * NOTE: set_nil is only available for nillable properties
 
372
         */
 
373
 
 
374
        
 
375
 
 
376
        /**
 
377
         * Check whether correlationId is nill
 
378
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
379
         * @param env pointer to environment struct
 
380
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
381
         */
 
382
        axis2_bool_t AXIS2_CALL
 
383
        adb_attachVolumeType_is_correlationId_nil(
 
384
                adb_attachVolumeType_t* _attachVolumeType,
 
385
                const axutil_env_t *env);
 
386
 
 
387
 
 
388
        
 
389
 
 
390
        /**
 
391
         * Check whether userId is nill
 
392
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
393
         * @param env pointer to environment struct
 
394
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
395
         */
 
396
        axis2_bool_t AXIS2_CALL
 
397
        adb_attachVolumeType_is_userId_nil(
 
398
                adb_attachVolumeType_t* _attachVolumeType,
 
399
                const axutil_env_t *env);
 
400
 
 
401
 
 
402
        
 
403
 
 
404
        /**
 
405
         * Check whether statusMessage is nill
 
406
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
407
         * @param env pointer to environment struct
 
408
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
409
         */
 
410
        axis2_bool_t AXIS2_CALL
 
411
        adb_attachVolumeType_is_statusMessage_nil(
 
412
                adb_attachVolumeType_t* _attachVolumeType,
 
413
                const axutil_env_t *env);
 
414
 
 
415
 
 
416
        
 
417
        /**
 
418
         * Set statusMessage to nill (currently the same as reset)
 
419
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
420
         * @param env pointer to environment struct
 
421
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
422
         */
 
423
        axis2_status_t AXIS2_CALL
 
424
        adb_attachVolumeType_set_statusMessage_nil(
 
425
                adb_attachVolumeType_t* _attachVolumeType,
 
426
                const axutil_env_t *env);
 
427
        
 
428
 
 
429
        /**
 
430
         * Check whether return is nill
 
431
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
432
         * @param env pointer to environment struct
 
433
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
434
         */
 
435
        axis2_bool_t AXIS2_CALL
 
436
        adb_attachVolumeType_is_return_nil(
 
437
                adb_attachVolumeType_t* _attachVolumeType,
 
438
                const axutil_env_t *env);
 
439
 
 
440
 
 
441
        
 
442
 
 
443
        /**
 
444
         * Check whether volumeId is nill
 
445
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
446
         * @param env pointer to environment struct
 
447
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
448
         */
 
449
        axis2_bool_t AXIS2_CALL
 
450
        adb_attachVolumeType_is_volumeId_nil(
 
451
                adb_attachVolumeType_t* _attachVolumeType,
 
452
                const axutil_env_t *env);
 
453
 
 
454
 
 
455
        
 
456
 
 
457
        /**
 
458
         * Check whether instanceId is nill
 
459
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
460
         * @param env pointer to environment struct
 
461
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
462
         */
 
463
        axis2_bool_t AXIS2_CALL
 
464
        adb_attachVolumeType_is_instanceId_nil(
 
465
                adb_attachVolumeType_t* _attachVolumeType,
 
466
                const axutil_env_t *env);
 
467
 
 
468
 
 
469
        
 
470
 
 
471
        /**
 
472
         * Check whether remoteDev is nill
 
473
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
474
         * @param env pointer to environment struct
 
475
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
476
         */
 
477
        axis2_bool_t AXIS2_CALL
 
478
        adb_attachVolumeType_is_remoteDev_nil(
 
479
                adb_attachVolumeType_t* _attachVolumeType,
 
480
                const axutil_env_t *env);
 
481
 
 
482
 
 
483
        
 
484
 
 
485
        /**
 
486
         * Check whether localDev is nill
 
487
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
488
         * @param env pointer to environment struct
 
489
         * @return AXIS2_TRUE if the element is nil or AXIS2_FALSE otherwise
 
490
         */
 
491
        axis2_bool_t AXIS2_CALL
 
492
        adb_attachVolumeType_is_localDev_nil(
 
493
                adb_attachVolumeType_t* _attachVolumeType,
 
494
                const axutil_env_t *env);
 
495
 
 
496
 
 
497
        
 
498
 
 
499
        /**************************** Serialize and Deserialize functions ***************************/
 
500
        /*********** These functions are for use only inside the generated code *********************/
 
501
 
 
502
        
 
503
        /**
 
504
         * Deserialize an XML to adb objects
 
505
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
506
         * @param env pointer to environment struct
 
507
         * @param dp_parent double pointer to the parent node to deserialize
 
508
         * @param dp_is_early_node_valid double pointer to a flag (is_early_node_valid?)
 
509
         * @param dont_care_minoccurs Dont set errors on validating minoccurs, 
 
510
         *              (Parent will order this in a case of choice)
 
511
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
512
         */
 
513
        axis2_status_t AXIS2_CALL
 
514
        adb_attachVolumeType_deserialize(
 
515
            adb_attachVolumeType_t* _attachVolumeType,
 
516
            const axutil_env_t *env,
 
517
            axiom_node_t** dp_parent,
 
518
            axis2_bool_t *dp_is_early_node_valid,
 
519
            axis2_bool_t dont_care_minoccurs);
 
520
                            
 
521
            
 
522
 
 
523
       /**
 
524
         * Declare namespace in the most parent node 
 
525
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
526
         * @param env pointer to environment struct
 
527
         * @param parent_element parent element
 
528
         * @param namespaces hash of namespace uri to prefix
 
529
         * @param next_ns_index pointer to an int which contain the next namespace index
 
530
         */
 
531
       void AXIS2_CALL
 
532
       adb_attachVolumeType_declare_parent_namespaces(
 
533
                    adb_attachVolumeType_t* _attachVolumeType,
 
534
                    const axutil_env_t *env, axiom_element_t *parent_element,
 
535
                    axutil_hash_t *namespaces, int *next_ns_index);
 
536
 
 
537
        
 
538
 
 
539
        /**
 
540
         * Serialize to an XML from the adb objects
 
541
         * @param  _attachVolumeType adb_attachVolumeType_t object
 
542
         * @param env pointer to environment struct
 
543
         * @param attachVolumeType_om_node node to serialize from
 
544
         * @param attachVolumeType_om_element parent element to serialize from
 
545
         * @param tag_closed whether the parent tag is closed or not
 
546
         * @param namespaces hash of namespace uri to prefix
 
547
         * @param next_ns_index an int which contain the next namespace index
 
548
         * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE
 
549
         */
 
550
        axiom_node_t* AXIS2_CALL
 
551
        adb_attachVolumeType_serialize(
 
552
            adb_attachVolumeType_t* _attachVolumeType,
 
553
            const axutil_env_t *env,
 
554
            axiom_node_t* attachVolumeType_om_node, axiom_element_t *attachVolumeType_om_element, int tag_closed, axutil_hash_t *namespaces, int *next_ns_index);
 
555
 
 
556
        /**
 
557
         * Check whether the adb_attachVolumeType is a particle class (E.g. group, inner sequence)
 
558
         * @return whether this is a particle class.
 
559
         */
 
560
        axis2_bool_t AXIS2_CALL
 
561
        adb_attachVolumeType_is_particle();
 
562
 
 
563
 
 
564
     #ifdef __cplusplus
 
565
     }
 
566
     #endif
 
567
 
 
568
     #endif /* ADB_ATTACHVOLUMETYPE_H */
 
569
    
 
570