← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cluster/generated/adb_ncRebootInstanceResponseType.c

  • 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_ncRebootInstanceResponseType.c
 
1
 
 
2
 
 
3
        /**
 
4
         * adb_ncRebootInstanceResponseType.c
 
5
         *
 
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)
 
8
         */
 
9
 
 
10
        #include "adb_ncRebootInstanceResponseType.h"
 
11
        
 
12
                /*
 
13
                 * This type was generated from the piece of schema that had
 
14
                 * name = ncRebootInstanceResponseType
 
15
                 * Namespace URI = http://eucalyptus.ucsb.edu/
 
16
                 * Namespace Prefix = ns1
 
17
                 */
 
18
           
 
19
 
 
20
 
 
21
        struct adb_ncRebootInstanceResponseType
 
22
        {
 
23
            axis2_char_t* property_correlationId;
 
24
 
 
25
                
 
26
                axis2_bool_t is_valid_correlationId;
 
27
 
 
28
 
 
29
            axis2_char_t* property_userId;
 
30
 
 
31
                
 
32
                axis2_bool_t is_valid_userId;
 
33
 
 
34
 
 
35
            axis2_bool_t property_return;
 
36
 
 
37
                
 
38
                axis2_bool_t is_valid_return;
 
39
 
 
40
 
 
41
            axis2_char_t* property_nodeName;
 
42
 
 
43
                
 
44
                axis2_bool_t is_valid_nodeName;
 
45
 
 
46
 
 
47
            int property_statusMessage;
 
48
 
 
49
                
 
50
                axis2_bool_t is_valid_statusMessage;
 
51
 
 
52
 
 
53
            axis2_bool_t property_status;
 
54
 
 
55
                
 
56
                axis2_bool_t is_valid_status;
 
57
 
 
58
 
 
59
            
 
60
        };
 
61
 
 
62
 
 
63
       /************************* Private Function prototypes ********************************/
 
64
        
 
65
 
 
66
                axis2_status_t AXIS2_CALL
 
67
                adb_ncRebootInstanceResponseType_set_userId_nil(
 
68
                        adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
69
                        const axutil_env_t *env);
 
70
            
 
71
 
 
72
                axis2_status_t AXIS2_CALL
 
73
                adb_ncRebootInstanceResponseType_set_return_nil(
 
74
                        adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
75
                        const axutil_env_t *env);
 
76
            
 
77
 
 
78
                axis2_status_t AXIS2_CALL
 
79
                adb_ncRebootInstanceResponseType_set_status_nil(
 
80
                        adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
81
                        const axutil_env_t *env);
 
82
            
 
83
 
 
84
 
 
85
       /************************* Function Implmentations ********************************/
 
86
        adb_ncRebootInstanceResponseType_t* AXIS2_CALL
 
87
        adb_ncRebootInstanceResponseType_create(
 
88
            const axutil_env_t *env)
 
89
        {
 
90
            adb_ncRebootInstanceResponseType_t *_ncRebootInstanceResponseType = NULL;
 
91
            
 
92
            AXIS2_ENV_CHECK(env, NULL);
 
93
 
 
94
            _ncRebootInstanceResponseType = (adb_ncRebootInstanceResponseType_t *) AXIS2_MALLOC(env->
 
95
                allocator, sizeof(adb_ncRebootInstanceResponseType_t));
 
96
 
 
97
            if(NULL == _ncRebootInstanceResponseType)
 
98
            {
 
99
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
 
100
                return NULL;
 
101
            }
 
102
 
 
103
            memset(_ncRebootInstanceResponseType, 0, sizeof(adb_ncRebootInstanceResponseType_t));
 
104
 
 
105
            _ncRebootInstanceResponseType->property_correlationId  = NULL;
 
106
                  _ncRebootInstanceResponseType->is_valid_correlationId  = AXIS2_FALSE;
 
107
            _ncRebootInstanceResponseType->property_userId  = NULL;
 
108
                  _ncRebootInstanceResponseType->is_valid_userId  = AXIS2_FALSE;
 
109
            _ncRebootInstanceResponseType->is_valid_return  = AXIS2_FALSE;
 
110
            _ncRebootInstanceResponseType->property_nodeName  = NULL;
 
111
                  _ncRebootInstanceResponseType->is_valid_nodeName  = AXIS2_FALSE;
 
112
            _ncRebootInstanceResponseType->is_valid_statusMessage  = AXIS2_FALSE;
 
113
            _ncRebootInstanceResponseType->is_valid_status  = AXIS2_FALSE;
 
114
            
 
115
 
 
116
            return _ncRebootInstanceResponseType;
 
117
        }
 
118
 
 
119
        axis2_status_t AXIS2_CALL
 
120
        adb_ncRebootInstanceResponseType_free (
 
121
                adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
122
                const axutil_env_t *env)
 
123
        {
 
124
            
 
125
 
 
126
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
127
            AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
128
 
 
129
            adb_ncRebootInstanceResponseType_reset_correlationId(_ncRebootInstanceResponseType, env);
 
130
            adb_ncRebootInstanceResponseType_reset_userId(_ncRebootInstanceResponseType, env);
 
131
            adb_ncRebootInstanceResponseType_reset_return(_ncRebootInstanceResponseType, env);
 
132
            adb_ncRebootInstanceResponseType_reset_nodeName(_ncRebootInstanceResponseType, env);
 
133
            adb_ncRebootInstanceResponseType_reset_statusMessage(_ncRebootInstanceResponseType, env);
 
134
            adb_ncRebootInstanceResponseType_reset_status(_ncRebootInstanceResponseType, env);
 
135
            
 
136
 
 
137
            if(_ncRebootInstanceResponseType)
 
138
            {
 
139
                AXIS2_FREE(env->allocator, _ncRebootInstanceResponseType);
 
140
                _ncRebootInstanceResponseType = NULL;
 
141
            }
 
142
            return AXIS2_SUCCESS;
 
143
        }
 
144
 
 
145
 
 
146
        
 
147
 
 
148
        axis2_status_t AXIS2_CALL
 
149
        adb_ncRebootInstanceResponseType_deserialize(
 
150
                adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
151
                const axutil_env_t *env,
 
152
                axiom_node_t **dp_parent,
 
153
                axis2_bool_t *dp_is_early_node_valid,
 
154
                axis2_bool_t dont_care_minoccurs)
 
155
        {
 
156
          axiom_node_t *parent = *dp_parent;
 
157
          
 
158
          axis2_status_t status = AXIS2_SUCCESS;
 
159
           
 
160
             axis2_char_t* text_value = NULL;
 
161
             axutil_qname_t *qname = NULL;
 
162
          
 
163
            axutil_qname_t *element_qname = NULL; 
 
164
            
 
165
               axiom_node_t *first_node = NULL;
 
166
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
 
167
               axiom_node_t *current_node = NULL;
 
168
               axiom_element_t *current_element = NULL;
 
169
            
 
170
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
171
            AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
172
 
 
173
            
 
174
              
 
175
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
 
176
              {
 
177
                  parent = axiom_node_get_next_sibling(parent, env);
 
178
              }
 
179
              if (NULL == parent)
 
180
              {
 
181
                /* This should be checked before everything */
 
182
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
 
183
                            "Failed in building adb object for ncRebootInstanceResponseType : "
 
184
                            "NULL elemenet can not be passed to deserialize");
 
185
                return AXIS2_FAILURE;
 
186
              }
 
187
              
 
188
                      
 
189
                      first_node = axiom_node_get_first_child(parent, env);
 
190
                      
 
191
                    
 
192
 
 
193
                     
 
194
                     /*
 
195
                      * building correlationId element
 
196
                      */
 
197
                     
 
198
                     
 
199
                     
 
200
                                   current_node = first_node;
 
201
                                   is_early_node_valid = AXIS2_FALSE;
 
202
                                   
 
203
                                   
 
204
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
205
                                    {
 
206
                                        current_node = axiom_node_get_next_sibling(current_node, env);
 
207
                                    }
 
208
                                    if(current_node != NULL)
 
209
                                    {
 
210
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
211
                                        qname = axiom_element_get_qname(current_element, env, current_node);
 
212
                                    }
 
213
                                   
 
214
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
 
215
                                 
 
216
 
 
217
                           if ( 
 
218
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
219
                           {
 
220
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
221
                              {
 
222
                                is_early_node_valid = AXIS2_TRUE;
 
223
                              }
 
224
                              
 
225
                                 
 
226
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
227
                                      if(text_value != NULL)
 
228
                                      {
 
229
                                            status = adb_ncRebootInstanceResponseType_set_correlationId(_ncRebootInstanceResponseType, env,
 
230
                                                               text_value);
 
231
                                      }
 
232
                                      
 
233
                                 if(AXIS2_FAILURE ==  status)
 
234
                                 {
 
235
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
 
236
                                     if(element_qname)
 
237
                                     {
 
238
                                         axutil_qname_free(element_qname, env);
 
239
                                     }
 
240
                                     return AXIS2_FAILURE;
 
241
                                 }
 
242
                              }
 
243
                           
 
244
                  if(element_qname)
 
245
                  {
 
246
                     axutil_qname_free(element_qname, env);
 
247
                     element_qname = NULL;
 
248
                  }
 
249
                 
 
250
 
 
251
                     
 
252
                     /*
 
253
                      * building userId element
 
254
                      */
 
255
                     
 
256
                     
 
257
                     
 
258
                                    /*
 
259
                                     * because elements are ordered this works fine
 
260
                                     */
 
261
                                  
 
262
                                   
 
263
                                   if(current_node != NULL && is_early_node_valid)
 
264
                                   {
 
265
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
266
                                       
 
267
                                       
 
268
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
269
                                        {
 
270
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
271
                                        }
 
272
                                        if(current_node != NULL)
 
273
                                        {
 
274
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
275
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
276
                                        }
 
277
                                       
 
278
                                   }
 
279
                                   is_early_node_valid = AXIS2_FALSE;
 
280
                                 
 
281
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
 
282
                                 
 
283
 
 
284
                           if ( 
 
285
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
286
                           {
 
287
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
288
                              {
 
289
                                is_early_node_valid = AXIS2_TRUE;
 
290
                              }
 
291
                              
 
292
                                 
 
293
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
294
                                      if(text_value != NULL)
 
295
                                      {
 
296
                                            status = adb_ncRebootInstanceResponseType_set_userId(_ncRebootInstanceResponseType, env,
 
297
                                                               text_value);
 
298
                                      }
 
299
                                      
 
300
                                      else
 
301
                                      {
 
302
                                            /*
 
303
                                             * axis2_qname_t *qname = NULL;
 
304
                                             * axiom_attribute_t *the_attri = NULL;
 
305
                                             * 
 
306
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
 
307
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
 
308
                                             */
 
309
                                            /* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
 
310
 
 
311
                                            axiom_attribute_t *the_attri = NULL;
 
312
                                            axis2_char_t *attrib_text = NULL;
 
313
                                            axutil_hash_t *attribute_hash = NULL;
 
314
 
 
315
                                            attribute_hash = axiom_element_get_all_attributes(current_element, env);
 
316
 
 
317
                                            attrib_text = NULL;
 
318
                                            if(attribute_hash)
 
319
                                            {
 
320
                                                 axutil_hash_index_t *hi;
 
321
                                                 void *val;
 
322
                                                 const void *key;
 
323
                                        
 
324
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
 
325
                                                 {
 
326
                                                     axutil_hash_this(hi, &key, NULL, &val);
 
327
                                                     
 
328
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
 
329
                                                     {
 
330
                                                         the_attri = (axiom_attribute_t*)val;
 
331
                                                         break;
 
332
                                                     }
 
333
                                                 }
 
334
                                            }
 
335
 
 
336
                                            if(the_attri)
 
337
                                            {
 
338
                                                attrib_text = axiom_attribute_get_value(the_attri, env);
 
339
                                            }
 
340
                                            else
 
341
                                            {
 
342
                                                /* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
 
343
                                                attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
 
344
                                            }
 
345
 
 
346
                                            if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
 
347
                                            {
 
348
                                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
 
349
                                                status = AXIS2_FAILURE;
 
350
                                            }
 
351
                                            else
 
352
                                            {
 
353
                                                /* after all, we found this is a empty string */
 
354
                                                status = adb_ncRebootInstanceResponseType_set_userId(_ncRebootInstanceResponseType, env,
 
355
                                                                   "");
 
356
                                            }
 
357
                                      }
 
358
                                      
 
359
                                 if(AXIS2_FAILURE ==  status)
 
360
                                 {
 
361
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
 
362
                                     if(element_qname)
 
363
                                     {
 
364
                                         axutil_qname_free(element_qname, env);
 
365
                                     }
 
366
                                     return AXIS2_FAILURE;
 
367
                                 }
 
368
                              }
 
369
                           
 
370
                  if(element_qname)
 
371
                  {
 
372
                     axutil_qname_free(element_qname, env);
 
373
                     element_qname = NULL;
 
374
                  }
 
375
                 
 
376
 
 
377
                     
 
378
                     /*
 
379
                      * building return element
 
380
                      */
 
381
                     
 
382
                     
 
383
                     
 
384
                                    /*
 
385
                                     * because elements are ordered this works fine
 
386
                                     */
 
387
                                  
 
388
                                   
 
389
                                   if(current_node != NULL && is_early_node_valid)
 
390
                                   {
 
391
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
392
                                       
 
393
                                       
 
394
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
395
                                        {
 
396
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
397
                                        }
 
398
                                        if(current_node != NULL)
 
399
                                        {
 
400
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
401
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
402
                                        }
 
403
                                       
 
404
                                   }
 
405
                                   is_early_node_valid = AXIS2_FALSE;
 
406
                                 
 
407
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
 
408
                                 
 
409
 
 
410
                           if ( 
 
411
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
412
                           {
 
413
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
414
                              {
 
415
                                is_early_node_valid = AXIS2_TRUE;
 
416
                              }
 
417
                              
 
418
                                 
 
419
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
420
                                      if(text_value != NULL)
 
421
                                      {
 
422
                                            if (!axutil_strcasecmp(text_value , "true"))
 
423
                                            {
 
424
                                                status = adb_ncRebootInstanceResponseType_set_return(_ncRebootInstanceResponseType, env,
 
425
                                                                 AXIS2_TRUE);
 
426
                                            }
 
427
                                            else
 
428
                                            {
 
429
                                                status = adb_ncRebootInstanceResponseType_set_return(_ncRebootInstanceResponseType, env,
 
430
                                                                      AXIS2_FALSE);
 
431
                                            }
 
432
                                      }
 
433
                                      
 
434
                                      else
 
435
                                      {
 
436
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
 
437
                                          status = AXIS2_FAILURE;
 
438
                                      }
 
439
                                      
 
440
                                 if(AXIS2_FAILURE ==  status)
 
441
                                 {
 
442
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
 
443
                                     if(element_qname)
 
444
                                     {
 
445
                                         axutil_qname_free(element_qname, env);
 
446
                                     }
 
447
                                     return AXIS2_FAILURE;
 
448
                                 }
 
449
                              }
 
450
                           
 
451
                  if(element_qname)
 
452
                  {
 
453
                     axutil_qname_free(element_qname, env);
 
454
                     element_qname = NULL;
 
455
                  }
 
456
                 
 
457
 
 
458
                     
 
459
                     /*
 
460
                      * building nodeName element
 
461
                      */
 
462
                     
 
463
                     
 
464
                     
 
465
                                    /*
 
466
                                     * because elements are ordered this works fine
 
467
                                     */
 
468
                                  
 
469
                                   
 
470
                                   if(current_node != NULL && is_early_node_valid)
 
471
                                   {
 
472
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
473
                                       
 
474
                                       
 
475
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
476
                                        {
 
477
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
478
                                        }
 
479
                                        if(current_node != NULL)
 
480
                                        {
 
481
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
482
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
483
                                        }
 
484
                                       
 
485
                                   }
 
486
                                   is_early_node_valid = AXIS2_FALSE;
 
487
                                 
 
488
                                 element_qname = axutil_qname_create(env, "nodeName", "http://eucalyptus.ucsb.edu/", NULL);
 
489
                                 
 
490
 
 
491
                           if ( 
 
492
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
493
                           {
 
494
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
495
                              {
 
496
                                is_early_node_valid = AXIS2_TRUE;
 
497
                              }
 
498
                              
 
499
                                 
 
500
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
501
                                      if(text_value != NULL)
 
502
                                      {
 
503
                                            status = adb_ncRebootInstanceResponseType_set_nodeName(_ncRebootInstanceResponseType, env,
 
504
                                                               text_value);
 
505
                                      }
 
506
                                      
 
507
                                 if(AXIS2_FAILURE ==  status)
 
508
                                 {
 
509
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeName ");
 
510
                                     if(element_qname)
 
511
                                     {
 
512
                                         axutil_qname_free(element_qname, env);
 
513
                                     }
 
514
                                     return AXIS2_FAILURE;
 
515
                                 }
 
516
                              }
 
517
                           
 
518
                  if(element_qname)
 
519
                  {
 
520
                     axutil_qname_free(element_qname, env);
 
521
                     element_qname = NULL;
 
522
                  }
 
523
                 
 
524
 
 
525
                     
 
526
                     /*
 
527
                      * building statusMessage element
 
528
                      */
 
529
                     
 
530
                     
 
531
                     
 
532
                                    /*
 
533
                                     * because elements are ordered this works fine
 
534
                                     */
 
535
                                  
 
536
                                   
 
537
                                   if(current_node != NULL && is_early_node_valid)
 
538
                                   {
 
539
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
540
                                       
 
541
                                       
 
542
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
543
                                        {
 
544
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
545
                                        }
 
546
                                        if(current_node != NULL)
 
547
                                        {
 
548
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
549
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
550
                                        }
 
551
                                       
 
552
                                   }
 
553
                                   is_early_node_valid = AXIS2_FALSE;
 
554
                                 
 
555
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
 
556
                                 
 
557
 
 
558
                           if ( 
 
559
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
560
                           {
 
561
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
562
                              {
 
563
                                is_early_node_valid = AXIS2_TRUE;
 
564
                              }
 
565
                              
 
566
                                 
 
567
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
568
                                      if(text_value != NULL)
 
569
                                      {
 
570
                                            status = adb_ncRebootInstanceResponseType_set_statusMessage(_ncRebootInstanceResponseType, env,
 
571
                                                                   atoi(text_value));
 
572
                                      }
 
573
                                      
 
574
                                 if(AXIS2_FAILURE ==  status)
 
575
                                 {
 
576
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
 
577
                                     if(element_qname)
 
578
                                     {
 
579
                                         axutil_qname_free(element_qname, env);
 
580
                                     }
 
581
                                     return AXIS2_FAILURE;
 
582
                                 }
 
583
                              }
 
584
                           
 
585
                  if(element_qname)
 
586
                  {
 
587
                     axutil_qname_free(element_qname, env);
 
588
                     element_qname = NULL;
 
589
                  }
 
590
                 
 
591
 
 
592
                     
 
593
                     /*
 
594
                      * building status element
 
595
                      */
 
596
                     
 
597
                     
 
598
                     
 
599
                                    /*
 
600
                                     * because elements are ordered this works fine
 
601
                                     */
 
602
                                  
 
603
                                   
 
604
                                   if(current_node != NULL && is_early_node_valid)
 
605
                                   {
 
606
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
607
                                       
 
608
                                       
 
609
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
610
                                        {
 
611
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
612
                                        }
 
613
                                        if(current_node != NULL)
 
614
                                        {
 
615
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
616
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
617
                                        }
 
618
                                       
 
619
                                   }
 
620
                                   is_early_node_valid = AXIS2_FALSE;
 
621
                                 
 
622
                                 element_qname = axutil_qname_create(env, "status", "http://eucalyptus.ucsb.edu/", NULL);
 
623
                                 
 
624
 
 
625
                           if ( 
 
626
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
627
                           {
 
628
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
629
                              {
 
630
                                is_early_node_valid = AXIS2_TRUE;
 
631
                              }
 
632
                              
 
633
                                 
 
634
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
635
                                      if(text_value != NULL)
 
636
                                      {
 
637
                                            if (!axutil_strcasecmp(text_value , "true"))
 
638
                                            {
 
639
                                                status = adb_ncRebootInstanceResponseType_set_status(_ncRebootInstanceResponseType, env,
 
640
                                                                 AXIS2_TRUE);
 
641
                                            }
 
642
                                            else
 
643
                                            {
 
644
                                                status = adb_ncRebootInstanceResponseType_set_status(_ncRebootInstanceResponseType, env,
 
645
                                                                      AXIS2_FALSE);
 
646
                                            }
 
647
                                      }
 
648
                                      
 
649
                                      else
 
650
                                      {
 
651
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element status");
 
652
                                          status = AXIS2_FAILURE;
 
653
                                      }
 
654
                                      
 
655
                                 if(AXIS2_FAILURE ==  status)
 
656
                                 {
 
657
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for status ");
 
658
                                     if(element_qname)
 
659
                                     {
 
660
                                         axutil_qname_free(element_qname, env);
 
661
                                     }
 
662
                                     return AXIS2_FAILURE;
 
663
                                 }
 
664
                              }
 
665
                           
 
666
                              else if(!dont_care_minoccurs)
 
667
                              {
 
668
                                  if(element_qname)
 
669
                                  {
 
670
                                      axutil_qname_free(element_qname, env);
 
671
                                  }
 
672
                                  /* this is not a nillable element*/
 
673
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element status missing");
 
674
                                  return AXIS2_FAILURE;
 
675
                              }
 
676
                           
 
677
                  if(element_qname)
 
678
                  {
 
679
                     axutil_qname_free(element_qname, env);
 
680
                     element_qname = NULL;
 
681
                  }
 
682
                 
 
683
          return status;
 
684
       }
 
685
 
 
686
          axis2_bool_t AXIS2_CALL
 
687
          adb_ncRebootInstanceResponseType_is_particle()
 
688
          {
 
689
            
 
690
                 return AXIS2_FALSE;
 
691
              
 
692
          }
 
693
 
 
694
 
 
695
          void AXIS2_CALL
 
696
          adb_ncRebootInstanceResponseType_declare_parent_namespaces(
 
697
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
698
                    const axutil_env_t *env, axiom_element_t *parent_element,
 
699
                    axutil_hash_t *namespaces, int *next_ns_index)
 
700
          {
 
701
            
 
702
                  /* Here this is an empty function, Nothing to declare */
 
703
                 
 
704
          }
 
705
 
 
706
        
 
707
        
 
708
        axiom_node_t* AXIS2_CALL
 
709
        adb_ncRebootInstanceResponseType_serialize(
 
710
                adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
711
                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)
 
712
        {
 
713
            
 
714
            
 
715
             axis2_char_t *string_to_stream;
 
716
            
 
717
         
 
718
         axiom_node_t *current_node = NULL;
 
719
         int tag_closed = 0;
 
720
 
 
721
         
 
722
         
 
723
                axiom_namespace_t *ns1 = NULL;
 
724
 
 
725
                axis2_char_t *qname_uri = NULL;
 
726
                axis2_char_t *qname_prefix = NULL;
 
727
                axis2_char_t *p_prefix = NULL;
 
728
                axis2_bool_t ns_already_defined;
 
729
            
 
730
                    axis2_char_t *text_value_1;
 
731
                    axis2_char_t *text_value_1_temp;
 
732
                    
 
733
                    axis2_char_t *text_value_2;
 
734
                    axis2_char_t *text_value_2_temp;
 
735
                    
 
736
                    axis2_char_t text_value_3[64];
 
737
                    
 
738
                    axis2_char_t *text_value_4;
 
739
                    axis2_char_t *text_value_4_temp;
 
740
                    
 
741
                    axis2_char_t text_value_5[64];
 
742
                    
 
743
                    axis2_char_t text_value_6[64];
 
744
                    
 
745
               axis2_char_t *start_input_str = NULL;
 
746
               axis2_char_t *end_input_str = NULL;
 
747
               unsigned int start_input_str_len = 0;
 
748
               unsigned int end_input_str_len = 0;
 
749
            
 
750
            
 
751
               axiom_data_source_t *data_source = NULL;
 
752
               axutil_stream_t *stream = NULL;
 
753
 
 
754
            
 
755
 
 
756
            AXIS2_ENV_CHECK(env, NULL);
 
757
            AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, NULL);
 
758
            
 
759
            
 
760
                    current_node = parent;
 
761
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
 
762
                    if (!data_source)
 
763
                        return NULL;
 
764
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
 
765
                    if (!stream)
 
766
                        return NULL;
 
767
                  
 
768
            if(!parent_tag_closed)
 
769
            {
 
770
            
 
771
              string_to_stream = ">"; 
 
772
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
 
773
              tag_closed = 1;
 
774
            
 
775
            }
 
776
            
 
777
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
778
                       {
 
779
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
780
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
781
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
782
                           
 
783
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
784
                                            "http://eucalyptus.ucsb.edu/",
 
785
                                            p_prefix));
 
786
                       }
 
787
                      
 
788
 
 
789
                   if (!_ncRebootInstanceResponseType->is_valid_correlationId)
 
790
                   {
 
791
                      
 
792
                           /* no need to complain for minoccurs=0 element */
 
793
                            
 
794
                          
 
795
                   }
 
796
                   else
 
797
                   {
 
798
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
799
                                 (4 + axutil_strlen(p_prefix) + 
 
800
                                  axutil_strlen("correlationId"))); 
 
801
                                 
 
802
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
803
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
804
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
 
805
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
806
                                  
 
807
                     
 
808
 
 
809
                   
 
810
                   
 
811
                     
 
812
                     /*
 
813
                      * parsing correlationId element
 
814
                      */
 
815
 
 
816
                    
 
817
                    
 
818
                            sprintf(start_input_str, "<%s%scorrelationId>",
 
819
                                 p_prefix?p_prefix:"",
 
820
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
821
                            
 
822
                        start_input_str_len = axutil_strlen(start_input_str);
 
823
                        sprintf(end_input_str, "</%s%scorrelationId>",
 
824
                                 p_prefix?p_prefix:"",
 
825
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
826
                        end_input_str_len = axutil_strlen(end_input_str);
 
827
                    
 
828
                           text_value_1 = _ncRebootInstanceResponseType->property_correlationId;
 
829
                           
 
830
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
831
                           
 
832
                            
 
833
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
 
834
                           if (text_value_1_temp)
 
835
                           {
 
836
                               axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
 
837
                               AXIS2_FREE(env->allocator, text_value_1_temp);
 
838
                           }
 
839
                           else
 
840
                           {
 
841
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
 
842
                           }
 
843
                           
 
844
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
845
                           
 
846
                     
 
847
                     AXIS2_FREE(env->allocator,start_input_str);
 
848
                     AXIS2_FREE(env->allocator,end_input_str);
 
849
                 } 
 
850
 
 
851
                 
 
852
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
853
                       {
 
854
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
855
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
856
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
857
                           
 
858
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
859
                                            "http://eucalyptus.ucsb.edu/",
 
860
                                            p_prefix));
 
861
                       }
 
862
                      
 
863
 
 
864
                   if (!_ncRebootInstanceResponseType->is_valid_userId)
 
865
                   {
 
866
                      
 
867
                           /* no need to complain for minoccurs=0 element */
 
868
                            
 
869
                          
 
870
                   }
 
871
                   else
 
872
                   {
 
873
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
874
                                 (4 + axutil_strlen(p_prefix) + 
 
875
                                  axutil_strlen("userId"))); 
 
876
                                 
 
877
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
878
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
879
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
 
880
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
881
                                  
 
882
                     
 
883
 
 
884
                   
 
885
                   
 
886
                     
 
887
                     /*
 
888
                      * parsing userId element
 
889
                      */
 
890
 
 
891
                    
 
892
                    
 
893
                            sprintf(start_input_str, "<%s%suserId>",
 
894
                                 p_prefix?p_prefix:"",
 
895
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
896
                            
 
897
                        start_input_str_len = axutil_strlen(start_input_str);
 
898
                        sprintf(end_input_str, "</%s%suserId>",
 
899
                                 p_prefix?p_prefix:"",
 
900
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
901
                        end_input_str_len = axutil_strlen(end_input_str);
 
902
                    
 
903
                           text_value_2 = _ncRebootInstanceResponseType->property_userId;
 
904
                           
 
905
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
906
                           
 
907
                            
 
908
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
 
909
                           if (text_value_2_temp)
 
910
                           {
 
911
                               axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
 
912
                               AXIS2_FREE(env->allocator, text_value_2_temp);
 
913
                           }
 
914
                           else
 
915
                           {
 
916
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
 
917
                           }
 
918
                           
 
919
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
920
                           
 
921
                     
 
922
                     AXIS2_FREE(env->allocator,start_input_str);
 
923
                     AXIS2_FREE(env->allocator,end_input_str);
 
924
                 } 
 
925
 
 
926
                 
 
927
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
928
                       {
 
929
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
930
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
931
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
932
                           
 
933
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
934
                                            "http://eucalyptus.ucsb.edu/",
 
935
                                            p_prefix));
 
936
                       }
 
937
                      
 
938
 
 
939
                   if (!_ncRebootInstanceResponseType->is_valid_return)
 
940
                   {
 
941
                      
 
942
                           /* no need to complain for minoccurs=0 element */
 
943
                            
 
944
                          
 
945
                   }
 
946
                   else
 
947
                   {
 
948
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
949
                                 (4 + axutil_strlen(p_prefix) + 
 
950
                                  axutil_strlen("return"))); 
 
951
                                 
 
952
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
953
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
954
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
 
955
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
956
                                  
 
957
                     
 
958
 
 
959
                   
 
960
                   
 
961
                     
 
962
                     /*
 
963
                      * parsing return element
 
964
                      */
 
965
 
 
966
                    
 
967
                    
 
968
                            sprintf(start_input_str, "<%s%sreturn>",
 
969
                                 p_prefix?p_prefix:"",
 
970
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
971
                            
 
972
                        start_input_str_len = axutil_strlen(start_input_str);
 
973
                        sprintf(end_input_str, "</%s%sreturn>",
 
974
                                 p_prefix?p_prefix:"",
 
975
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
976
                        end_input_str_len = axutil_strlen(end_input_str);
 
977
                    
 
978
                           strcpy(text_value_3, (_ncRebootInstanceResponseType->property_return)?"true":"false");
 
979
                           
 
980
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
981
                           
 
982
                           axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
 
983
                           
 
984
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
985
                           
 
986
                     
 
987
                     AXIS2_FREE(env->allocator,start_input_str);
 
988
                     AXIS2_FREE(env->allocator,end_input_str);
 
989
                 } 
 
990
 
 
991
                 
 
992
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
993
                       {
 
994
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
995
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
996
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
997
                           
 
998
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
999
                                            "http://eucalyptus.ucsb.edu/",
 
1000
                                            p_prefix));
 
1001
                       }
 
1002
                      
 
1003
 
 
1004
                   if (!_ncRebootInstanceResponseType->is_valid_nodeName)
 
1005
                   {
 
1006
                      
 
1007
                           /* no need to complain for minoccurs=0 element */
 
1008
                            
 
1009
                          
 
1010
                   }
 
1011
                   else
 
1012
                   {
 
1013
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1014
                                 (4 + axutil_strlen(p_prefix) + 
 
1015
                                  axutil_strlen("nodeName"))); 
 
1016
                                 
 
1017
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
1018
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1019
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("nodeName")));
 
1020
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
1021
                                  
 
1022
                     
 
1023
 
 
1024
                   
 
1025
                   
 
1026
                     
 
1027
                     /*
 
1028
                      * parsing nodeName element
 
1029
                      */
 
1030
 
 
1031
                    
 
1032
                    
 
1033
                            sprintf(start_input_str, "<%s%snodeName>",
 
1034
                                 p_prefix?p_prefix:"",
 
1035
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1036
                            
 
1037
                        start_input_str_len = axutil_strlen(start_input_str);
 
1038
                        sprintf(end_input_str, "</%s%snodeName>",
 
1039
                                 p_prefix?p_prefix:"",
 
1040
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1041
                        end_input_str_len = axutil_strlen(end_input_str);
 
1042
                    
 
1043
                           text_value_4 = _ncRebootInstanceResponseType->property_nodeName;
 
1044
                           
 
1045
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
1046
                           
 
1047
                            
 
1048
                           text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
 
1049
                           if (text_value_4_temp)
 
1050
                           {
 
1051
                               axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
 
1052
                               AXIS2_FREE(env->allocator, text_value_4_temp);
 
1053
                           }
 
1054
                           else
 
1055
                           {
 
1056
                               axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
 
1057
                           }
 
1058
                           
 
1059
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
1060
                           
 
1061
                     
 
1062
                     AXIS2_FREE(env->allocator,start_input_str);
 
1063
                     AXIS2_FREE(env->allocator,end_input_str);
 
1064
                 } 
 
1065
 
 
1066
                 
 
1067
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
1068
                       {
 
1069
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
1070
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
1071
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
1072
                           
 
1073
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
1074
                                            "http://eucalyptus.ucsb.edu/",
 
1075
                                            p_prefix));
 
1076
                       }
 
1077
                      
 
1078
 
 
1079
                   if (!_ncRebootInstanceResponseType->is_valid_statusMessage)
 
1080
                   {
 
1081
                      
 
1082
                           /* no need to complain for minoccurs=0 element */
 
1083
                            
 
1084
                          
 
1085
                   }
 
1086
                   else
 
1087
                   {
 
1088
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1089
                                 (4 + axutil_strlen(p_prefix) + 
 
1090
                                  axutil_strlen("statusMessage"))); 
 
1091
                                 
 
1092
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
1093
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1094
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
 
1095
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
1096
                                  
 
1097
                     
 
1098
 
 
1099
                   
 
1100
                   
 
1101
                     
 
1102
                     /*
 
1103
                      * parsing statusMessage element
 
1104
                      */
 
1105
 
 
1106
                    
 
1107
                    
 
1108
                            sprintf(start_input_str, "<%s%sstatusMessage>",
 
1109
                                 p_prefix?p_prefix:"",
 
1110
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1111
                            
 
1112
                        start_input_str_len = axutil_strlen(start_input_str);
 
1113
                        sprintf(end_input_str, "</%s%sstatusMessage>",
 
1114
                                 p_prefix?p_prefix:"",
 
1115
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1116
                        end_input_str_len = axutil_strlen(end_input_str);
 
1117
                    
 
1118
                               sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncRebootInstanceResponseType->property_statusMessage);
 
1119
                             
 
1120
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
1121
                           
 
1122
                           axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
 
1123
                           
 
1124
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
1125
                           
 
1126
                     
 
1127
                     AXIS2_FREE(env->allocator,start_input_str);
 
1128
                     AXIS2_FREE(env->allocator,end_input_str);
 
1129
                 } 
 
1130
 
 
1131
                 
 
1132
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
1133
                       {
 
1134
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
1135
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
1136
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
1137
                           
 
1138
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
1139
                                            "http://eucalyptus.ucsb.edu/",
 
1140
                                            p_prefix));
 
1141
                       }
 
1142
                      
 
1143
 
 
1144
                   if (!_ncRebootInstanceResponseType->is_valid_status)
 
1145
                   {
 
1146
                      
 
1147
                            
 
1148
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property status");
 
1149
                            return NULL;
 
1150
                          
 
1151
                   }
 
1152
                   else
 
1153
                   {
 
1154
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1155
                                 (4 + axutil_strlen(p_prefix) + 
 
1156
                                  axutil_strlen("status"))); 
 
1157
                                 
 
1158
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
1159
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1160
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("status")));
 
1161
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
1162
                                  
 
1163
                     
 
1164
 
 
1165
                   
 
1166
                   
 
1167
                     
 
1168
                     /*
 
1169
                      * parsing status element
 
1170
                      */
 
1171
 
 
1172
                    
 
1173
                    
 
1174
                            sprintf(start_input_str, "<%s%sstatus>",
 
1175
                                 p_prefix?p_prefix:"",
 
1176
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1177
                            
 
1178
                        start_input_str_len = axutil_strlen(start_input_str);
 
1179
                        sprintf(end_input_str, "</%s%sstatus>",
 
1180
                                 p_prefix?p_prefix:"",
 
1181
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1182
                        end_input_str_len = axutil_strlen(end_input_str);
 
1183
                    
 
1184
                           strcpy(text_value_6, (_ncRebootInstanceResponseType->property_status)?"true":"false");
 
1185
                           
 
1186
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
1187
                           
 
1188
                           axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
 
1189
                           
 
1190
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
1191
                           
 
1192
                     
 
1193
                     AXIS2_FREE(env->allocator,start_input_str);
 
1194
                     AXIS2_FREE(env->allocator,end_input_str);
 
1195
                 } 
 
1196
 
 
1197
                 
 
1198
 
 
1199
            return parent;
 
1200
        }
 
1201
 
 
1202
 
 
1203
        
 
1204
 
 
1205
            /**
 
1206
             * getter for correlationId.
 
1207
             */
 
1208
            axis2_char_t* AXIS2_CALL
 
1209
            adb_ncRebootInstanceResponseType_get_correlationId(
 
1210
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1211
                    const axutil_env_t *env)
 
1212
             {
 
1213
                
 
1214
                    AXIS2_ENV_CHECK(env, NULL);
 
1215
                    AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, NULL);
 
1216
                  
 
1217
 
 
1218
                return _ncRebootInstanceResponseType->property_correlationId;
 
1219
             }
 
1220
 
 
1221
            /**
 
1222
             * setter for correlationId
 
1223
             */
 
1224
            axis2_status_t AXIS2_CALL
 
1225
            adb_ncRebootInstanceResponseType_set_correlationId(
 
1226
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1227
                    const axutil_env_t *env,
 
1228
                    const axis2_char_t*  arg_correlationId)
 
1229
             {
 
1230
                
 
1231
 
 
1232
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1233
                AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1234
                
 
1235
                if(_ncRebootInstanceResponseType->is_valid_correlationId &&
 
1236
                        arg_correlationId == _ncRebootInstanceResponseType->property_correlationId)
 
1237
                {
 
1238
                    
 
1239
                    return AXIS2_SUCCESS; 
 
1240
                }
 
1241
 
 
1242
                adb_ncRebootInstanceResponseType_reset_correlationId(_ncRebootInstanceResponseType, env);
 
1243
 
 
1244
                
 
1245
                if(NULL == arg_correlationId)
 
1246
                {
 
1247
                    /* We are already done */
 
1248
                    return AXIS2_SUCCESS;
 
1249
                }
 
1250
                _ncRebootInstanceResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
 
1251
                        if(NULL == _ncRebootInstanceResponseType->property_correlationId)
 
1252
                        {
 
1253
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
 
1254
                            return AXIS2_FAILURE;
 
1255
                        }
 
1256
                        _ncRebootInstanceResponseType->is_valid_correlationId = AXIS2_TRUE;
 
1257
                    
 
1258
                return AXIS2_SUCCESS;
 
1259
             }
 
1260
 
 
1261
             
 
1262
 
 
1263
           /**
 
1264
            * resetter for correlationId
 
1265
            */
 
1266
           axis2_status_t AXIS2_CALL
 
1267
           adb_ncRebootInstanceResponseType_reset_correlationId(
 
1268
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1269
                   const axutil_env_t *env)
 
1270
           {
 
1271
               int i = 0;
 
1272
               int count = 0;
 
1273
               void *element = NULL;
 
1274
 
 
1275
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1276
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1277
               
 
1278
 
 
1279
               
 
1280
            
 
1281
                
 
1282
                if(_ncRebootInstanceResponseType->property_correlationId != NULL)
 
1283
                {
 
1284
                   
 
1285
                   
 
1286
                        AXIS2_FREE(env-> allocator, _ncRebootInstanceResponseType->property_correlationId);
 
1287
                     _ncRebootInstanceResponseType->property_correlationId = NULL;
 
1288
                }
 
1289
            
 
1290
                
 
1291
                
 
1292
                _ncRebootInstanceResponseType->is_valid_correlationId = AXIS2_FALSE; 
 
1293
               return AXIS2_SUCCESS;
 
1294
           }
 
1295
 
 
1296
           /**
 
1297
            * Check whether correlationId is nill
 
1298
            */
 
1299
           axis2_bool_t AXIS2_CALL
 
1300
           adb_ncRebootInstanceResponseType_is_correlationId_nil(
 
1301
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1302
                   const axutil_env_t *env)
 
1303
           {
 
1304
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1305
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_TRUE);
 
1306
               
 
1307
               return !_ncRebootInstanceResponseType->is_valid_correlationId;
 
1308
           }
 
1309
 
 
1310
           /**
 
1311
            * Set correlationId to nill (currently the same as reset)
 
1312
            */
 
1313
           axis2_status_t AXIS2_CALL
 
1314
           adb_ncRebootInstanceResponseType_set_correlationId_nil(
 
1315
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1316
                   const axutil_env_t *env)
 
1317
           {
 
1318
               return adb_ncRebootInstanceResponseType_reset_correlationId(_ncRebootInstanceResponseType, env);
 
1319
           }
 
1320
 
 
1321
           
 
1322
 
 
1323
            /**
 
1324
             * getter for userId.
 
1325
             */
 
1326
            axis2_char_t* AXIS2_CALL
 
1327
            adb_ncRebootInstanceResponseType_get_userId(
 
1328
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1329
                    const axutil_env_t *env)
 
1330
             {
 
1331
                
 
1332
                    AXIS2_ENV_CHECK(env, NULL);
 
1333
                    AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, NULL);
 
1334
                  
 
1335
 
 
1336
                return _ncRebootInstanceResponseType->property_userId;
 
1337
             }
 
1338
 
 
1339
            /**
 
1340
             * setter for userId
 
1341
             */
 
1342
            axis2_status_t AXIS2_CALL
 
1343
            adb_ncRebootInstanceResponseType_set_userId(
 
1344
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1345
                    const axutil_env_t *env,
 
1346
                    const axis2_char_t*  arg_userId)
 
1347
             {
 
1348
                
 
1349
 
 
1350
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1351
                AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1352
                
 
1353
                if(_ncRebootInstanceResponseType->is_valid_userId &&
 
1354
                        arg_userId == _ncRebootInstanceResponseType->property_userId)
 
1355
                {
 
1356
                    
 
1357
                    return AXIS2_SUCCESS; 
 
1358
                }
 
1359
 
 
1360
                adb_ncRebootInstanceResponseType_reset_userId(_ncRebootInstanceResponseType, env);
 
1361
 
 
1362
                
 
1363
                if(NULL == arg_userId)
 
1364
                {
 
1365
                    /* We are already done */
 
1366
                    return AXIS2_SUCCESS;
 
1367
                }
 
1368
                _ncRebootInstanceResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
 
1369
                        if(NULL == _ncRebootInstanceResponseType->property_userId)
 
1370
                        {
 
1371
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
 
1372
                            return AXIS2_FAILURE;
 
1373
                        }
 
1374
                        _ncRebootInstanceResponseType->is_valid_userId = AXIS2_TRUE;
 
1375
                    
 
1376
                return AXIS2_SUCCESS;
 
1377
             }
 
1378
 
 
1379
             
 
1380
 
 
1381
           /**
 
1382
            * resetter for userId
 
1383
            */
 
1384
           axis2_status_t AXIS2_CALL
 
1385
           adb_ncRebootInstanceResponseType_reset_userId(
 
1386
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1387
                   const axutil_env_t *env)
 
1388
           {
 
1389
               int i = 0;
 
1390
               int count = 0;
 
1391
               void *element = NULL;
 
1392
 
 
1393
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1394
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1395
               
 
1396
 
 
1397
               
 
1398
            
 
1399
                
 
1400
                if(_ncRebootInstanceResponseType->property_userId != NULL)
 
1401
                {
 
1402
                   
 
1403
                   
 
1404
                        AXIS2_FREE(env-> allocator, _ncRebootInstanceResponseType->property_userId);
 
1405
                     _ncRebootInstanceResponseType->property_userId = NULL;
 
1406
                }
 
1407
            
 
1408
                
 
1409
                
 
1410
                _ncRebootInstanceResponseType->is_valid_userId = AXIS2_FALSE; 
 
1411
               return AXIS2_SUCCESS;
 
1412
           }
 
1413
 
 
1414
           /**
 
1415
            * Check whether userId is nill
 
1416
            */
 
1417
           axis2_bool_t AXIS2_CALL
 
1418
           adb_ncRebootInstanceResponseType_is_userId_nil(
 
1419
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1420
                   const axutil_env_t *env)
 
1421
           {
 
1422
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1423
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_TRUE);
 
1424
               
 
1425
               return !_ncRebootInstanceResponseType->is_valid_userId;
 
1426
           }
 
1427
 
 
1428
           /**
 
1429
            * Set userId to nill (currently the same as reset)
 
1430
            */
 
1431
           axis2_status_t AXIS2_CALL
 
1432
           adb_ncRebootInstanceResponseType_set_userId_nil(
 
1433
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1434
                   const axutil_env_t *env)
 
1435
           {
 
1436
               return adb_ncRebootInstanceResponseType_reset_userId(_ncRebootInstanceResponseType, env);
 
1437
           }
 
1438
 
 
1439
           
 
1440
 
 
1441
            /**
 
1442
             * getter for return.
 
1443
             */
 
1444
            axis2_bool_t AXIS2_CALL
 
1445
            adb_ncRebootInstanceResponseType_get_return(
 
1446
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1447
                    const axutil_env_t *env)
 
1448
             {
 
1449
                
 
1450
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
 
1451
                    AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, (axis2_bool_t)0);
 
1452
                  
 
1453
 
 
1454
                return _ncRebootInstanceResponseType->property_return;
 
1455
             }
 
1456
 
 
1457
            /**
 
1458
             * setter for return
 
1459
             */
 
1460
            axis2_status_t AXIS2_CALL
 
1461
            adb_ncRebootInstanceResponseType_set_return(
 
1462
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1463
                    const axutil_env_t *env,
 
1464
                    axis2_bool_t  arg_return)
 
1465
             {
 
1466
                
 
1467
 
 
1468
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1469
                AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1470
                
 
1471
                if(_ncRebootInstanceResponseType->is_valid_return &&
 
1472
                        arg_return == _ncRebootInstanceResponseType->property_return)
 
1473
                {
 
1474
                    
 
1475
                    return AXIS2_SUCCESS; 
 
1476
                }
 
1477
 
 
1478
                adb_ncRebootInstanceResponseType_reset_return(_ncRebootInstanceResponseType, env);
 
1479
 
 
1480
                _ncRebootInstanceResponseType->property_return = arg_return;
 
1481
                        _ncRebootInstanceResponseType->is_valid_return = AXIS2_TRUE;
 
1482
                    
 
1483
                return AXIS2_SUCCESS;
 
1484
             }
 
1485
 
 
1486
             
 
1487
 
 
1488
           /**
 
1489
            * resetter for return
 
1490
            */
 
1491
           axis2_status_t AXIS2_CALL
 
1492
           adb_ncRebootInstanceResponseType_reset_return(
 
1493
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1494
                   const axutil_env_t *env)
 
1495
           {
 
1496
               int i = 0;
 
1497
               int count = 0;
 
1498
               void *element = NULL;
 
1499
 
 
1500
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1501
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1502
               
 
1503
 
 
1504
               _ncRebootInstanceResponseType->is_valid_return = AXIS2_FALSE; 
 
1505
               return AXIS2_SUCCESS;
 
1506
           }
 
1507
 
 
1508
           /**
 
1509
            * Check whether return is nill
 
1510
            */
 
1511
           axis2_bool_t AXIS2_CALL
 
1512
           adb_ncRebootInstanceResponseType_is_return_nil(
 
1513
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1514
                   const axutil_env_t *env)
 
1515
           {
 
1516
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1517
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_TRUE);
 
1518
               
 
1519
               return !_ncRebootInstanceResponseType->is_valid_return;
 
1520
           }
 
1521
 
 
1522
           /**
 
1523
            * Set return to nill (currently the same as reset)
 
1524
            */
 
1525
           axis2_status_t AXIS2_CALL
 
1526
           adb_ncRebootInstanceResponseType_set_return_nil(
 
1527
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1528
                   const axutil_env_t *env)
 
1529
           {
 
1530
               return adb_ncRebootInstanceResponseType_reset_return(_ncRebootInstanceResponseType, env);
 
1531
           }
 
1532
 
 
1533
           
 
1534
 
 
1535
            /**
 
1536
             * getter for nodeName.
 
1537
             */
 
1538
            axis2_char_t* AXIS2_CALL
 
1539
            adb_ncRebootInstanceResponseType_get_nodeName(
 
1540
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1541
                    const axutil_env_t *env)
 
1542
             {
 
1543
                
 
1544
                    AXIS2_ENV_CHECK(env, NULL);
 
1545
                    AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, NULL);
 
1546
                  
 
1547
 
 
1548
                return _ncRebootInstanceResponseType->property_nodeName;
 
1549
             }
 
1550
 
 
1551
            /**
 
1552
             * setter for nodeName
 
1553
             */
 
1554
            axis2_status_t AXIS2_CALL
 
1555
            adb_ncRebootInstanceResponseType_set_nodeName(
 
1556
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1557
                    const axutil_env_t *env,
 
1558
                    const axis2_char_t*  arg_nodeName)
 
1559
             {
 
1560
                
 
1561
 
 
1562
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1563
                AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1564
                
 
1565
                if(_ncRebootInstanceResponseType->is_valid_nodeName &&
 
1566
                        arg_nodeName == _ncRebootInstanceResponseType->property_nodeName)
 
1567
                {
 
1568
                    
 
1569
                    return AXIS2_SUCCESS; 
 
1570
                }
 
1571
 
 
1572
                adb_ncRebootInstanceResponseType_reset_nodeName(_ncRebootInstanceResponseType, env);
 
1573
 
 
1574
                
 
1575
                if(NULL == arg_nodeName)
 
1576
                {
 
1577
                    /* We are already done */
 
1578
                    return AXIS2_SUCCESS;
 
1579
                }
 
1580
                _ncRebootInstanceResponseType->property_nodeName = (axis2_char_t *)axutil_strdup(env, arg_nodeName);
 
1581
                        if(NULL == _ncRebootInstanceResponseType->property_nodeName)
 
1582
                        {
 
1583
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeName");
 
1584
                            return AXIS2_FAILURE;
 
1585
                        }
 
1586
                        _ncRebootInstanceResponseType->is_valid_nodeName = AXIS2_TRUE;
 
1587
                    
 
1588
                return AXIS2_SUCCESS;
 
1589
             }
 
1590
 
 
1591
             
 
1592
 
 
1593
           /**
 
1594
            * resetter for nodeName
 
1595
            */
 
1596
           axis2_status_t AXIS2_CALL
 
1597
           adb_ncRebootInstanceResponseType_reset_nodeName(
 
1598
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1599
                   const axutil_env_t *env)
 
1600
           {
 
1601
               int i = 0;
 
1602
               int count = 0;
 
1603
               void *element = NULL;
 
1604
 
 
1605
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1606
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1607
               
 
1608
 
 
1609
               
 
1610
            
 
1611
                
 
1612
                if(_ncRebootInstanceResponseType->property_nodeName != NULL)
 
1613
                {
 
1614
                   
 
1615
                   
 
1616
                        AXIS2_FREE(env-> allocator, _ncRebootInstanceResponseType->property_nodeName);
 
1617
                     _ncRebootInstanceResponseType->property_nodeName = NULL;
 
1618
                }
 
1619
            
 
1620
                
 
1621
                
 
1622
                _ncRebootInstanceResponseType->is_valid_nodeName = AXIS2_FALSE; 
 
1623
               return AXIS2_SUCCESS;
 
1624
           }
 
1625
 
 
1626
           /**
 
1627
            * Check whether nodeName is nill
 
1628
            */
 
1629
           axis2_bool_t AXIS2_CALL
 
1630
           adb_ncRebootInstanceResponseType_is_nodeName_nil(
 
1631
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1632
                   const axutil_env_t *env)
 
1633
           {
 
1634
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1635
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_TRUE);
 
1636
               
 
1637
               return !_ncRebootInstanceResponseType->is_valid_nodeName;
 
1638
           }
 
1639
 
 
1640
           /**
 
1641
            * Set nodeName to nill (currently the same as reset)
 
1642
            */
 
1643
           axis2_status_t AXIS2_CALL
 
1644
           adb_ncRebootInstanceResponseType_set_nodeName_nil(
 
1645
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1646
                   const axutil_env_t *env)
 
1647
           {
 
1648
               return adb_ncRebootInstanceResponseType_reset_nodeName(_ncRebootInstanceResponseType, env);
 
1649
           }
 
1650
 
 
1651
           
 
1652
 
 
1653
            /**
 
1654
             * getter for statusMessage.
 
1655
             */
 
1656
            int AXIS2_CALL
 
1657
            adb_ncRebootInstanceResponseType_get_statusMessage(
 
1658
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1659
                    const axutil_env_t *env)
 
1660
             {
 
1661
                
 
1662
                    AXIS2_ENV_CHECK(env, (int)0);
 
1663
                    AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, (int)0);
 
1664
                  
 
1665
 
 
1666
                return _ncRebootInstanceResponseType->property_statusMessage;
 
1667
             }
 
1668
 
 
1669
            /**
 
1670
             * setter for statusMessage
 
1671
             */
 
1672
            axis2_status_t AXIS2_CALL
 
1673
            adb_ncRebootInstanceResponseType_set_statusMessage(
 
1674
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1675
                    const axutil_env_t *env,
 
1676
                    const int  arg_statusMessage)
 
1677
             {
 
1678
                
 
1679
 
 
1680
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1681
                AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1682
                
 
1683
                if(_ncRebootInstanceResponseType->is_valid_statusMessage &&
 
1684
                        arg_statusMessage == _ncRebootInstanceResponseType->property_statusMessage)
 
1685
                {
 
1686
                    
 
1687
                    return AXIS2_SUCCESS; 
 
1688
                }
 
1689
 
 
1690
                adb_ncRebootInstanceResponseType_reset_statusMessage(_ncRebootInstanceResponseType, env);
 
1691
 
 
1692
                _ncRebootInstanceResponseType->property_statusMessage = arg_statusMessage;
 
1693
                        _ncRebootInstanceResponseType->is_valid_statusMessage = AXIS2_TRUE;
 
1694
                    
 
1695
                return AXIS2_SUCCESS;
 
1696
             }
 
1697
 
 
1698
             
 
1699
 
 
1700
           /**
 
1701
            * resetter for statusMessage
 
1702
            */
 
1703
           axis2_status_t AXIS2_CALL
 
1704
           adb_ncRebootInstanceResponseType_reset_statusMessage(
 
1705
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1706
                   const axutil_env_t *env)
 
1707
           {
 
1708
               int i = 0;
 
1709
               int count = 0;
 
1710
               void *element = NULL;
 
1711
 
 
1712
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1713
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1714
               
 
1715
 
 
1716
               _ncRebootInstanceResponseType->is_valid_statusMessage = AXIS2_FALSE; 
 
1717
               return AXIS2_SUCCESS;
 
1718
           }
 
1719
 
 
1720
           /**
 
1721
            * Check whether statusMessage is nill
 
1722
            */
 
1723
           axis2_bool_t AXIS2_CALL
 
1724
           adb_ncRebootInstanceResponseType_is_statusMessage_nil(
 
1725
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1726
                   const axutil_env_t *env)
 
1727
           {
 
1728
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1729
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_TRUE);
 
1730
               
 
1731
               return !_ncRebootInstanceResponseType->is_valid_statusMessage;
 
1732
           }
 
1733
 
 
1734
           /**
 
1735
            * Set statusMessage to nill (currently the same as reset)
 
1736
            */
 
1737
           axis2_status_t AXIS2_CALL
 
1738
           adb_ncRebootInstanceResponseType_set_statusMessage_nil(
 
1739
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1740
                   const axutil_env_t *env)
 
1741
           {
 
1742
               return adb_ncRebootInstanceResponseType_reset_statusMessage(_ncRebootInstanceResponseType, env);
 
1743
           }
 
1744
 
 
1745
           
 
1746
 
 
1747
            /**
 
1748
             * getter for status.
 
1749
             */
 
1750
            axis2_bool_t AXIS2_CALL
 
1751
            adb_ncRebootInstanceResponseType_get_status(
 
1752
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1753
                    const axutil_env_t *env)
 
1754
             {
 
1755
                
 
1756
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
 
1757
                    AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, (axis2_bool_t)0);
 
1758
                  
 
1759
 
 
1760
                return _ncRebootInstanceResponseType->property_status;
 
1761
             }
 
1762
 
 
1763
            /**
 
1764
             * setter for status
 
1765
             */
 
1766
            axis2_status_t AXIS2_CALL
 
1767
            adb_ncRebootInstanceResponseType_set_status(
 
1768
                    adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1769
                    const axutil_env_t *env,
 
1770
                    axis2_bool_t  arg_status)
 
1771
             {
 
1772
                
 
1773
 
 
1774
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1775
                AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1776
                
 
1777
                if(_ncRebootInstanceResponseType->is_valid_status &&
 
1778
                        arg_status == _ncRebootInstanceResponseType->property_status)
 
1779
                {
 
1780
                    
 
1781
                    return AXIS2_SUCCESS; 
 
1782
                }
 
1783
 
 
1784
                adb_ncRebootInstanceResponseType_reset_status(_ncRebootInstanceResponseType, env);
 
1785
 
 
1786
                _ncRebootInstanceResponseType->property_status = arg_status;
 
1787
                        _ncRebootInstanceResponseType->is_valid_status = AXIS2_TRUE;
 
1788
                    
 
1789
                return AXIS2_SUCCESS;
 
1790
             }
 
1791
 
 
1792
             
 
1793
 
 
1794
           /**
 
1795
            * resetter for status
 
1796
            */
 
1797
           axis2_status_t AXIS2_CALL
 
1798
           adb_ncRebootInstanceResponseType_reset_status(
 
1799
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1800
                   const axutil_env_t *env)
 
1801
           {
 
1802
               int i = 0;
 
1803
               int count = 0;
 
1804
               void *element = NULL;
 
1805
 
 
1806
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1807
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_FAILURE);
 
1808
               
 
1809
 
 
1810
               _ncRebootInstanceResponseType->is_valid_status = AXIS2_FALSE; 
 
1811
               return AXIS2_SUCCESS;
 
1812
           }
 
1813
 
 
1814
           /**
 
1815
            * Check whether status is nill
 
1816
            */
 
1817
           axis2_bool_t AXIS2_CALL
 
1818
           adb_ncRebootInstanceResponseType_is_status_nil(
 
1819
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1820
                   const axutil_env_t *env)
 
1821
           {
 
1822
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1823
               AXIS2_PARAM_CHECK(env->error, _ncRebootInstanceResponseType, AXIS2_TRUE);
 
1824
               
 
1825
               return !_ncRebootInstanceResponseType->is_valid_status;
 
1826
           }
 
1827
 
 
1828
           /**
 
1829
            * Set status to nill (currently the same as reset)
 
1830
            */
 
1831
           axis2_status_t AXIS2_CALL
 
1832
           adb_ncRebootInstanceResponseType_set_status_nil(
 
1833
                   adb_ncRebootInstanceResponseType_t* _ncRebootInstanceResponseType,
 
1834
                   const axutil_env_t *env)
 
1835
           {
 
1836
               return adb_ncRebootInstanceResponseType_reset_status(_ncRebootInstanceResponseType, env);
 
1837
           }
 
1838
 
 
1839
           
 
1840