← Back to branch summary

~ubuntu-branches/ubuntu/maverick/eucalyptus/maverick

« back to all changes in this revision

Viewing changes to cluster/generated/adb_rebootInstancesType.c

  • Committer: Bazaar Package Importer
  • Author(s): Dave Walker (Daviey)
  • Date: 2010-07-21 17:27:10 UTC
  • mfrom: (1.1.38 upstream)
  • Revision ID: james.westby@ubuntu.com-20100721172710-7xv07dmdqgivc3t9
Tags: 2.0~bzr1211-0ubuntu1
https://launchpad.net/bugs/597330
https://launchpad.net/bugs/595421
* New major upstream version merge, 2.0 (r1211).
* debian/patches/:
  - 01-wsdl-stubs.patch, debian/wsdl.md5sums: wsdl stubs updated.
  - 02-Makefile.patch: Updated to reflect new code layout.
  - 07-local_support_euca_conf-in.patch: Updated to reflect new code layout.
  - 08-ubuntu-default-networking.patch: Refreshed.
  - 09-small-128-192MB.patch: Updated to point to new location.
  - 10-disable-iscsi.patch: Refreshed.
  - 11-state-cleanup-memleakfix.patch: Removed, fixed upstream.
  - 15-fix-default-ramdisk.patch: Updated to point to new location.
  - 16-kvm_libvirt_xml_default_use_kvm.patch: Updated to reflect changes.
  - 17-fix_walrus_OOM_errors.patch: Removed, fixed upstream.
  - 18-priv_security.patch: Updated to reflect upstream changes.
  - 20-brute-force-webui.patch: Updated to reflect upstream changes. 
  - 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_rebootInstancesType.c
8
8
         */
9
9
 
10
10
        #include "adb_rebootInstancesType.h"
11
 
 
 
11
        
12
12
                /*
13
13
                 * This type was generated from the piece of schema that had
14
14
                 * name = rebootInstancesType
15
15
                 * Namespace URI = http://eucalyptus.ucsb.edu/
16
16
                 * Namespace Prefix = ns1
17
17
                 */
18
 
 
 
18
           
19
19
 
20
20
 
21
21
        struct adb_rebootInstancesType
22
22
        {
23
23
            axis2_char_t* property_correlationId;
24
24
 
25
 
 
 
25
                
26
26
                axis2_bool_t is_valid_correlationId;
27
27
 
28
28
 
29
29
            axis2_char_t* property_userId;
30
30
 
31
 
 
 
31
                
32
32
                axis2_bool_t is_valid_userId;
33
33
 
34
34
 
35
35
            axis2_char_t* property_statusMessage;
36
36
 
37
 
 
 
37
                
38
38
                axis2_bool_t is_valid_statusMessage;
39
39
 
40
40
 
41
41
            axis2_bool_t property_return;
42
42
 
43
 
 
 
43
                
44
44
                axis2_bool_t is_valid_return;
45
45
 
46
46
 
47
47
            axutil_array_list_t* property_instanceIds;
48
48
 
49
 
 
 
49
                
50
50
                axis2_bool_t is_valid_instanceIds;
51
51
 
52
52
 
53
 
 
 
53
            
54
54
        };
55
55
 
56
56
 
57
57
       /************************* Private Function prototypes ********************************/
58
 
 
 
58
        
59
59
 
60
60
                axis2_status_t AXIS2_CALL
61
61
                adb_rebootInstancesType_set_correlationId_nil(
62
62
                        adb_rebootInstancesType_t* _rebootInstancesType,
63
63
                        const axutil_env_t *env);
64
 
 
 
64
            
65
65
 
66
66
                axis2_status_t AXIS2_CALL
67
67
                adb_rebootInstancesType_set_userId_nil(
68
68
                        adb_rebootInstancesType_t* _rebootInstancesType,
69
69
                        const axutil_env_t *env);
70
 
 
 
70
            
71
71
 
72
72
                axis2_status_t AXIS2_CALL
73
73
                adb_rebootInstancesType_set_return_nil(
74
74
                        adb_rebootInstancesType_t* _rebootInstancesType,
75
75
                        const axutil_env_t *env);
76
 
 
 
76
            
77
77
                 axis2_status_t AXIS2_CALL
78
78
                 adb_rebootInstancesType_set_instanceIds_nil_at(
79
 
                        adb_rebootInstancesType_t* _rebootInstancesType,
 
79
                        adb_rebootInstancesType_t* _rebootInstancesType, 
80
80
                        const axutil_env_t *env, int i);
81
 
 
 
81
                
82
82
 
83
83
                axis2_status_t AXIS2_CALL
84
84
                adb_rebootInstancesType_set_instanceIds_nil(
85
85
                        adb_rebootInstancesType_t* _rebootInstancesType,
86
86
                        const axutil_env_t *env);
87
 
 
 
87
            
88
88
 
89
89
 
90
90
       /************************* Function Implmentations ********************************/
93
93
            const axutil_env_t *env)
94
94
        {
95
95
            adb_rebootInstancesType_t *_rebootInstancesType = NULL;
96
 
 
 
96
            
97
97
            AXIS2_ENV_CHECK(env, NULL);
98
98
 
99
99
            _rebootInstancesType = (adb_rebootInstancesType_t *) AXIS2_MALLOC(env->
116
116
            _rebootInstancesType->is_valid_return  = AXIS2_FALSE;
117
117
            _rebootInstancesType->property_instanceIds  = NULL;
118
118
                  _rebootInstancesType->is_valid_instanceIds  = AXIS2_FALSE;
119
 
 
 
119
            
120
120
 
121
121
            return _rebootInstancesType;
122
122
        }
126
126
                adb_rebootInstancesType_t* _rebootInstancesType,
127
127
                const axutil_env_t *env)
128
128
        {
129
 
 
 
129
            
130
130
                int i = 0;
131
131
                int count = 0;
132
132
                void *element = NULL;
133
 
 
 
133
            
134
134
 
135
135
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
136
136
            AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
140
140
            adb_rebootInstancesType_reset_statusMessage(_rebootInstancesType, env);
141
141
            adb_rebootInstancesType_reset_return(_rebootInstancesType, env);
142
142
            adb_rebootInstancesType_reset_instanceIds(_rebootInstancesType, env);
143
 
 
 
143
            
144
144
 
145
145
            if(_rebootInstancesType)
146
146
            {
151
151
        }
152
152
 
153
153
 
154
 
 
 
154
        
155
155
 
156
156
        axis2_status_t AXIS2_CALL
157
157
        adb_rebootInstancesType_deserialize(
162
162
                axis2_bool_t dont_care_minoccurs)
163
163
        {
164
164
          axiom_node_t *parent = *dp_parent;
165
 
 
 
165
          
166
166
          axis2_status_t status = AXIS2_SUCCESS;
167
 
 
 
167
          
168
168
              void *element = NULL;
169
 
 
 
169
           
170
170
             axis2_char_t* text_value = NULL;
171
171
             axutil_qname_t *qname = NULL;
172
 
 
 
172
          
173
173
               int i = 0;
174
174
               axutil_array_list_t *arr_list = NULL;
175
 
 
 
175
            
176
176
               int sequence_broken = 0;
177
177
               axiom_node_t *tmp_node = NULL;
178
 
 
179
 
            axutil_qname_t *element_qname = NULL;
180
 
 
 
178
            
 
179
            axutil_qname_t *element_qname = NULL; 
 
180
            
181
181
               axiom_node_t *first_node = NULL;
182
182
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
183
183
               axiom_node_t *current_node = NULL;
184
184
               axiom_element_t *current_element = NULL;
185
 
 
 
185
            
186
186
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
187
187
            AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
188
188
 
189
 
 
190
 
 
 
189
            
 
190
              
191
191
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
192
192
              {
193
193
                  parent = axiom_node_get_next_sibling(parent, env);
195
195
              if (NULL == parent)
196
196
              {
197
197
                /* This should be checked before everything */
198
 
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
 
198
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
199
199
                            "Failed in building adb object for rebootInstancesType : "
200
200
                            "NULL elemenet can not be passed to deserialize");
201
201
                return AXIS2_FAILURE;
202
202
              }
203
 
 
204
 
 
 
203
              
 
204
                      
205
205
                      first_node = axiom_node_get_first_child(parent, env);
206
 
 
207
 
 
208
 
 
209
 
 
 
206
                      
 
207
                    
 
208
 
 
209
                     
210
210
                     /*
211
211
                      * building correlationId element
212
212
                      */
213
 
 
214
 
 
215
 
 
 
213
                     
 
214
                     
 
215
                     
216
216
                                   current_node = first_node;
217
217
                                   is_early_node_valid = AXIS2_FALSE;
218
 
 
219
 
 
 
218
                                   
 
219
                                   
220
220
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
221
221
                                    {
222
222
                                        current_node = axiom_node_get_next_sibling(current_node, env);
226
226
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
227
227
                                        qname = axiom_element_get_qname(current_element, env, current_node);
228
228
                                    }
229
 
 
 
229
                                   
230
230
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
231
 
 
232
 
 
233
 
                           if (
 
231
                                 
 
232
 
 
233
                           if ( 
234
234
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
235
235
                           {
236
236
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
237
237
                              {
238
238
                                is_early_node_valid = AXIS2_TRUE;
239
239
                              }
240
 
 
241
 
 
 
240
                              
 
241
                                 
242
242
                                      text_value = axiom_element_get_text(current_element, env, current_node);
243
243
                                      if(text_value != NULL)
244
244
                                      {
245
245
                                            status = adb_rebootInstancesType_set_correlationId(_rebootInstancesType, env,
246
246
                                                               text_value);
247
247
                                      }
248
 
 
 
248
                                      
249
249
                                      else
250
250
                                      {
251
251
                                            /*
252
252
                                             * axis2_qname_t *qname = NULL;
253
253
                                             * axiom_attribute_t *the_attri = NULL;
254
 
                                             *
 
254
                                             * 
255
255
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
256
256
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
257
257
                                             */
269
269
                                                 axutil_hash_index_t *hi;
270
270
                                                 void *val;
271
271
                                                 const void *key;
272
 
 
273
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
272
                                        
 
273
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
274
274
                                                 {
275
275
                                                     axutil_hash_this(hi, &key, NULL, &val);
276
 
 
 
276
                                                     
277
277
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
278
278
                                                     {
279
279
                                                         the_attri = (axiom_attribute_t*)val;
304
304
                                                                   "");
305
305
                                            }
306
306
                                      }
307
 
 
 
307
                                      
308
308
                                 if(AXIS2_FAILURE ==  status)
309
309
                                 {
310
310
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
315
315
                                     return AXIS2_FAILURE;
316
316
                                 }
317
317
                              }
318
 
 
 
318
                           
319
319
                  if(element_qname)
320
320
                  {
321
321
                     axutil_qname_free(element_qname, env);
322
322
                     element_qname = NULL;
323
323
                  }
324
 
 
325
 
 
326
 
 
 
324
                 
 
325
 
 
326
                     
327
327
                     /*
328
328
                      * building userId element
329
329
                      */
330
 
 
331
 
 
332
 
 
 
330
                     
 
331
                     
 
332
                     
333
333
                                    /*
334
334
                                     * because elements are ordered this works fine
335
335
                                     */
336
 
 
337
 
 
 
336
                                  
 
337
                                   
338
338
                                   if(current_node != NULL && is_early_node_valid)
339
339
                                   {
340
340
                                       current_node = axiom_node_get_next_sibling(current_node, env);
341
 
 
342
 
 
 
341
                                       
 
342
                                       
343
343
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
344
344
                                        {
345
345
                                            current_node = axiom_node_get_next_sibling(current_node, env);
349
349
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
350
350
                                            qname = axiom_element_get_qname(current_element, env, current_node);
351
351
                                        }
352
 
 
 
352
                                       
353
353
                                   }
354
354
                                   is_early_node_valid = AXIS2_FALSE;
355
 
 
 
355
                                 
356
356
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
357
 
 
358
 
 
359
 
                           if (
 
357
                                 
 
358
 
 
359
                           if ( 
360
360
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
361
361
                           {
362
362
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
363
363
                              {
364
364
                                is_early_node_valid = AXIS2_TRUE;
365
365
                              }
366
 
 
367
 
 
 
366
                              
 
367
                                 
368
368
                                      text_value = axiom_element_get_text(current_element, env, current_node);
369
369
                                      if(text_value != NULL)
370
370
                                      {
371
371
                                            status = adb_rebootInstancesType_set_userId(_rebootInstancesType, env,
372
372
                                                               text_value);
373
373
                                      }
374
 
 
 
374
                                      
375
375
                                      else
376
376
                                      {
377
377
                                            /*
378
378
                                             * axis2_qname_t *qname = NULL;
379
379
                                             * axiom_attribute_t *the_attri = NULL;
380
 
                                             *
 
380
                                             * 
381
381
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
382
382
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
383
383
                                             */
395
395
                                                 axutil_hash_index_t *hi;
396
396
                                                 void *val;
397
397
                                                 const void *key;
398
 
 
399
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
398
                                        
 
399
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
400
400
                                                 {
401
401
                                                     axutil_hash_this(hi, &key, NULL, &val);
402
 
 
 
402
                                                     
403
403
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
404
404
                                                     {
405
405
                                                         the_attri = (axiom_attribute_t*)val;
430
430
                                                                   "");
431
431
                                            }
432
432
                                      }
433
 
 
 
433
                                      
434
434
                                 if(AXIS2_FAILURE ==  status)
435
435
                                 {
436
436
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
441
441
                                     return AXIS2_FAILURE;
442
442
                                 }
443
443
                              }
444
 
 
 
444
                           
445
445
                  if(element_qname)
446
446
                  {
447
447
                     axutil_qname_free(element_qname, env);
448
448
                     element_qname = NULL;
449
449
                  }
450
 
 
451
 
 
452
 
 
 
450
                 
 
451
 
 
452
                     
453
453
                     /*
454
454
                      * building statusMessage element
455
455
                      */
456
 
 
457
 
 
458
 
 
 
456
                     
 
457
                     
 
458
                     
459
459
                                    /*
460
460
                                     * because elements are ordered this works fine
461
461
                                     */
462
 
 
463
 
 
 
462
                                  
 
463
                                   
464
464
                                   if(current_node != NULL && is_early_node_valid)
465
465
                                   {
466
466
                                       current_node = axiom_node_get_next_sibling(current_node, env);
467
 
 
468
 
 
 
467
                                       
 
468
                                       
469
469
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
470
470
                                        {
471
471
                                            current_node = axiom_node_get_next_sibling(current_node, env);
475
475
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
476
476
                                            qname = axiom_element_get_qname(current_element, env, current_node);
477
477
                                        }
478
 
 
 
478
                                       
479
479
                                   }
480
480
                                   is_early_node_valid = AXIS2_FALSE;
481
 
 
 
481
                                 
482
482
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
483
 
 
484
 
 
485
 
                           if (
 
483
                                 
 
484
 
 
485
                           if ( 
486
486
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
487
487
                           {
488
488
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
489
489
                              {
490
490
                                is_early_node_valid = AXIS2_TRUE;
491
491
                              }
492
 
 
493
 
 
 
492
                              
 
493
                                 
494
494
                                      text_value = axiom_element_get_text(current_element, env, current_node);
495
495
                                      if(text_value != NULL)
496
496
                                      {
497
497
                                            status = adb_rebootInstancesType_set_statusMessage(_rebootInstancesType, env,
498
498
                                                               text_value);
499
499
                                      }
500
 
 
 
500
                                      
501
501
                                 if(AXIS2_FAILURE ==  status)
502
502
                                 {
503
503
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
508
508
                                     return AXIS2_FAILURE;
509
509
                                 }
510
510
                              }
511
 
 
 
511
                           
512
512
                  if(element_qname)
513
513
                  {
514
514
                     axutil_qname_free(element_qname, env);
515
515
                     element_qname = NULL;
516
516
                  }
517
 
 
518
 
 
519
 
 
 
517
                 
 
518
 
 
519
                     
520
520
                     /*
521
521
                      * building return element
522
522
                      */
523
 
 
524
 
 
525
 
 
 
523
                     
 
524
                     
 
525
                     
526
526
                                    /*
527
527
                                     * because elements are ordered this works fine
528
528
                                     */
529
 
 
530
 
 
 
529
                                  
 
530
                                   
531
531
                                   if(current_node != NULL && is_early_node_valid)
532
532
                                   {
533
533
                                       current_node = axiom_node_get_next_sibling(current_node, env);
534
 
 
535
 
 
 
534
                                       
 
535
                                       
536
536
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
537
537
                                        {
538
538
                                            current_node = axiom_node_get_next_sibling(current_node, env);
542
542
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
543
543
                                            qname = axiom_element_get_qname(current_element, env, current_node);
544
544
                                        }
545
 
 
 
545
                                       
546
546
                                   }
547
547
                                   is_early_node_valid = AXIS2_FALSE;
548
 
 
 
548
                                 
549
549
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
550
 
 
551
 
 
552
 
                           if (
 
550
                                 
 
551
 
 
552
                           if ( 
553
553
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
554
554
                           {
555
555
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
556
556
                              {
557
557
                                is_early_node_valid = AXIS2_TRUE;
558
558
                              }
559
 
 
560
 
 
 
559
                              
 
560
                                 
561
561
                                      text_value = axiom_element_get_text(current_element, env, current_node);
562
562
                                      if(text_value != NULL)
563
563
                                      {
572
572
                                                                      AXIS2_FALSE);
573
573
                                            }
574
574
                                      }
575
 
 
 
575
                                      
576
576
                                      else
577
577
                                      {
578
578
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
579
579
                                          status = AXIS2_FAILURE;
580
580
                                      }
581
 
 
 
581
                                      
582
582
                                 if(AXIS2_FAILURE ==  status)
583
583
                                 {
584
584
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
589
589
                                     return AXIS2_FAILURE;
590
590
                                 }
591
591
                              }
592
 
 
 
592
                           
593
593
                  if(element_qname)
594
594
                  {
595
595
                     axutil_qname_free(element_qname, env);
596
596
                     element_qname = NULL;
597
597
                  }
598
 
 
 
598
                 
599
599
                    /*
600
600
                     * building instanceIds array
601
601
                     */
602
602
                       arr_list = axutil_array_list_create(env, 10);
603
 
 
604
 
 
605
 
 
 
603
                   
 
604
 
 
605
                     
606
606
                     /*
607
607
                      * building instanceIds element
608
608
                      */
609
 
 
610
 
 
611
 
 
 
609
                     
 
610
                     
 
611
                     
612
612
                                    element_qname = axutil_qname_create(env, "instanceIds", "http://eucalyptus.ucsb.edu/", NULL);
613
 
 
614
 
 
615
 
                               for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;)
616
 
 
 
613
                                  
 
614
                               
 
615
                               for (i = 0, sequence_broken = 0, current_node = (is_early_node_valid?axiom_node_get_next_sibling(current_node, env):current_node); !sequence_broken && current_node != NULL;) 
 
616
                                             
617
617
                               {
618
618
                                  if(axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
619
619
                                  {
621
621
                                     is_early_node_valid = AXIS2_FALSE;
622
622
                                     continue;
623
623
                                  }
624
 
 
 
624
                                  
625
625
                                  current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
626
626
                                  qname = axiom_element_get_qname(current_element, env, current_node);
627
627
 
628
628
                                  if (axutil_qname_equals(element_qname, env, qname))
629
629
                                  {
630
 
 
 
630
                                  
631
631
                                      is_early_node_valid = AXIS2_TRUE;
632
 
 
633
 
 
 
632
                                      
 
633
                                     
634
634
                                          text_value = axiom_element_get_text(current_element, env, current_node);
635
635
                                          if(text_value != NULL)
636
636
                                          {
637
637
                                              axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, text_value));
638
638
                                          }
639
 
 
 
639
                                          
640
640
                                          else
641
641
                                          {
642
642
                                              /*
643
643
                                               * axis2_qname_t *qname = NULL;
644
644
                                               * axiom_attribute_t *the_attri = NULL;
645
 
                                               *
 
645
                                               * 
646
646
                                               * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
647
647
                                               * the_attri = axiom_element_get_attribute(current_element, env, qname);
648
648
                                               */
649
 
 
 
649
                                           
650
650
                                              /* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
651
 
 
 
651
                                             
652
652
                                              axiom_attribute_t *the_attri = NULL;
653
653
                                              axis2_char_t *attrib_text = NULL;
654
654
                                              axutil_hash_t *attribute_hash = NULL;
655
 
 
 
655
                                             
656
656
                                              attribute_hash = axiom_element_get_all_attributes(current_element, env);
657
 
 
 
657
                                             
658
658
                                              attrib_text = NULL;
659
659
                                              if(attribute_hash)
660
660
                                              {
661
661
                                                   axutil_hash_index_t *hi;
662
662
                                                   void *val;
663
663
                                                   const void *key;
664
 
 
665
 
                                                   for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
664
                                             
 
665
                                                   for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
666
666
                                                   {
667
667
                                                       axutil_hash_this(hi, &key, NULL, &val);
668
 
 
 
668
                                                       
669
669
                                                       if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
670
670
                                                       {
671
671
                                                           the_attri = (axiom_attribute_t*)val;
673
673
                                                       }
674
674
                                                   }
675
675
                                              }
676
 
 
 
676
                                             
677
677
                                              if(the_attri)
678
678
                                              {
679
679
                                                  attrib_text = axiom_attribute_get_value(the_attri, env);
683
683
                                                  /* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
684
684
                                                  attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
685
685
                                              }
686
 
 
 
686
                                             
687
687
                                              if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
688
688
                                              {
689
689
                                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element instanceIds");
695
695
                                                  axutil_array_list_add_at(arr_list, env, i, axutil_strdup(env, ""));
696
696
                                              }
697
697
                                          }
698
 
 
 
698
                                          
699
699
                                     if(AXIS2_FAILURE ==  status)
700
700
                                     {
701
701
                                         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for instanceIds ");
718
718
                                      is_early_node_valid = AXIS2_FALSE;
719
719
                                      sequence_broken = 1;
720
720
                                  }
721
 
 
 
721
                                  
722
722
                               }
723
723
 
724
 
 
 
724
                               
725
725
                                   if (i < 0)
726
726
                                   {
727
727
                                     /* found element out of order */
736
736
                                     }
737
737
                                     return AXIS2_FAILURE;
738
738
                                   }
739
 
 
 
739
                               
740
740
 
741
741
                               if(0 == axutil_array_list_size(arr_list,env))
742
742
                               {
748
748
                                                                   arr_list);
749
749
                               }
750
750
 
751
 
 
 
751
                             
752
752
                  if(element_qname)
753
753
                  {
754
754
                     axutil_qname_free(element_qname, env);
755
755
                     element_qname = NULL;
756
756
                  }
757
 
 
 
757
                 
758
758
          return status;
759
759
       }
760
760
 
761
761
          axis2_bool_t AXIS2_CALL
762
762
          adb_rebootInstancesType_is_particle()
763
763
          {
764
 
 
 
764
            
765
765
                 return AXIS2_FALSE;
766
 
 
 
766
              
767
767
          }
768
768
 
769
769
 
773
773
                    const axutil_env_t *env, axiom_element_t *parent_element,
774
774
                    axutil_hash_t *namespaces, int *next_ns_index)
775
775
          {
776
 
 
 
776
            
777
777
                  /* Here this is an empty function, Nothing to declare */
778
 
 
 
778
                 
779
779
          }
780
780
 
781
 
 
782
 
 
 
781
        
 
782
        
783
783
        axiom_node_t* AXIS2_CALL
784
784
        adb_rebootInstancesType_serialize(
785
785
                adb_rebootInstancesType_t* _rebootInstancesType,
786
786
                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)
787
787
        {
788
 
 
789
 
 
 
788
            
 
789
            
790
790
             axis2_char_t *string_to_stream;
791
 
 
792
 
 
 
791
            
 
792
         
793
793
         axiom_node_t *current_node = NULL;
794
794
         int tag_closed = 0;
795
795
 
796
 
 
797
 
 
 
796
         
 
797
         
798
798
                axiom_namespace_t *ns1 = NULL;
799
799
 
800
800
                axis2_char_t *qname_uri = NULL;
801
801
                axis2_char_t *qname_prefix = NULL;
802
802
                axis2_char_t *p_prefix = NULL;
803
803
                axis2_bool_t ns_already_defined;
804
 
 
 
804
            
805
805
               int i = 0;
806
806
               int count = 0;
807
807
               void *element = NULL;
808
 
 
 
808
             
809
809
                    axis2_char_t *text_value_1;
810
810
                    axis2_char_t *text_value_1_temp;
811
 
 
 
811
                    
812
812
                    axis2_char_t *text_value_2;
813
813
                    axis2_char_t *text_value_2_temp;
814
 
 
 
814
                    
815
815
                    axis2_char_t *text_value_3;
816
816
                    axis2_char_t *text_value_3_temp;
817
 
 
 
817
                    
818
818
                    axis2_char_t text_value_4[64];
819
 
 
 
819
                    
820
820
                    axis2_char_t *text_value_5;
821
821
                    axis2_char_t *text_value_5_temp;
822
 
 
 
822
                    
823
823
               axis2_char_t *start_input_str = NULL;
824
824
               axis2_char_t *end_input_str = NULL;
825
825
               unsigned int start_input_str_len = 0;
826
826
               unsigned int end_input_str_len = 0;
827
 
 
828
 
 
 
827
            
 
828
            
829
829
               axiom_data_source_t *data_source = NULL;
830
830
               axutil_stream_t *stream = NULL;
831
831
 
832
 
 
 
832
            
833
833
 
834
834
            AXIS2_ENV_CHECK(env, NULL);
835
835
            AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
836
 
 
837
 
 
 
836
            
 
837
            
838
838
                    current_node = parent;
839
839
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
840
840
                    if (!data_source)
842
842
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
843
843
                    if (!stream)
844
844
                        return NULL;
845
 
 
 
845
                  
846
846
            if(!parent_tag_closed)
847
847
            {
848
 
 
849
 
              string_to_stream = ">";
 
848
            
 
849
              string_to_stream = ">"; 
850
850
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
851
851
              tag_closed = 1;
852
 
 
 
852
            
853
853
            }
854
 
 
 
854
            
855
855
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
856
856
                       {
857
857
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
858
858
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
859
859
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
860
 
 
 
860
                           
861
861
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
862
862
                                            "http://eucalyptus.ucsb.edu/",
863
863
                                            p_prefix));
864
864
                       }
865
 
 
 
865
                      
866
866
 
867
867
                   if (!_rebootInstancesType->is_valid_correlationId)
868
868
                   {
869
 
 
 
869
                      
870
870
                           /* no need to complain for minoccurs=0 element */
871
 
 
872
 
 
 
871
                            
 
872
                          
873
873
                   }
874
874
                   else
875
875
                   {
876
876
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
877
 
                                 (4 + axutil_strlen(p_prefix) +
878
 
                                  axutil_strlen("correlationId")));
879
 
 
 
877
                                 (4 + axutil_strlen(p_prefix) + 
 
878
                                  axutil_strlen("correlationId"))); 
 
879
                                 
880
880
                                 /* axutil_strlen("<:>") + 1 = 4 */
881
881
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
882
882
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
883
883
                                  /* axutil_strlen("</:>") + 1 = 5 */
884
 
 
885
 
 
886
 
 
887
 
 
888
 
 
889
 
 
 
884
                                  
 
885
                     
 
886
 
 
887
                   
 
888
                   
 
889
                     
890
890
                     /*
891
891
                      * parsing correlationId element
892
892
                      */
893
893
 
894
 
 
895
 
 
 
894
                    
 
895
                    
896
896
                            sprintf(start_input_str, "<%s%scorrelationId>",
897
897
                                 p_prefix?p_prefix:"",
898
898
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
899
 
 
 
899
                            
900
900
                        start_input_str_len = axutil_strlen(start_input_str);
901
901
                        sprintf(end_input_str, "</%s%scorrelationId>",
902
902
                                 p_prefix?p_prefix:"",
903
903
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
904
904
                        end_input_str_len = axutil_strlen(end_input_str);
905
 
 
 
905
                    
906
906
                           text_value_1 = _rebootInstancesType->property_correlationId;
907
 
 
 
907
                           
908
908
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
909
 
 
910
 
 
 
909
                           
 
910
                            
911
911
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
912
912
                           if (text_value_1_temp)
913
913
                           {
918
918
                           {
919
919
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
920
920
                           }
921
 
 
 
921
                           
922
922
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
923
 
 
924
 
 
 
923
                           
 
924
                     
925
925
                     AXIS2_FREE(env->allocator,start_input_str);
926
926
                     AXIS2_FREE(env->allocator,end_input_str);
927
 
                 }
928
 
 
929
 
 
 
927
                 } 
 
928
 
 
929
                 
930
930
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
931
931
                       {
932
932
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
933
933
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
934
934
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
935
 
 
 
935
                           
936
936
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
937
937
                                            "http://eucalyptus.ucsb.edu/",
938
938
                                            p_prefix));
939
939
                       }
940
 
 
 
940
                      
941
941
 
942
942
                   if (!_rebootInstancesType->is_valid_userId)
943
943
                   {
944
 
 
 
944
                      
945
945
                           /* no need to complain for minoccurs=0 element */
946
 
 
947
 
 
 
946
                            
 
947
                          
948
948
                   }
949
949
                   else
950
950
                   {
951
951
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
952
 
                                 (4 + axutil_strlen(p_prefix) +
953
 
                                  axutil_strlen("userId")));
954
 
 
 
952
                                 (4 + axutil_strlen(p_prefix) + 
 
953
                                  axutil_strlen("userId"))); 
 
954
                                 
955
955
                                 /* axutil_strlen("<:>") + 1 = 4 */
956
956
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
957
957
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
958
958
                                  /* axutil_strlen("</:>") + 1 = 5 */
959
 
 
960
 
 
961
 
 
962
 
 
963
 
 
964
 
 
 
959
                                  
 
960
                     
 
961
 
 
962
                   
 
963
                   
 
964
                     
965
965
                     /*
966
966
                      * parsing userId element
967
967
                      */
968
968
 
969
 
 
970
 
 
 
969
                    
 
970
                    
971
971
                            sprintf(start_input_str, "<%s%suserId>",
972
972
                                 p_prefix?p_prefix:"",
973
973
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
974
 
 
 
974
                            
975
975
                        start_input_str_len = axutil_strlen(start_input_str);
976
976
                        sprintf(end_input_str, "</%s%suserId>",
977
977
                                 p_prefix?p_prefix:"",
978
978
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
979
979
                        end_input_str_len = axutil_strlen(end_input_str);
980
 
 
 
980
                    
981
981
                           text_value_2 = _rebootInstancesType->property_userId;
982
 
 
 
982
                           
983
983
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
984
 
 
985
 
 
 
984
                           
 
985
                            
986
986
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
987
987
                           if (text_value_2_temp)
988
988
                           {
993
993
                           {
994
994
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
995
995
                           }
996
 
 
 
996
                           
997
997
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
998
 
 
999
 
 
 
998
                           
 
999
                     
1000
1000
                     AXIS2_FREE(env->allocator,start_input_str);
1001
1001
                     AXIS2_FREE(env->allocator,end_input_str);
1002
 
                 }
1003
 
 
1004
 
 
 
1002
                 } 
 
1003
 
 
1004
                 
1005
1005
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1006
1006
                       {
1007
1007
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1008
1008
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1009
1009
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1010
 
 
 
1010
                           
1011
1011
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1012
1012
                                            "http://eucalyptus.ucsb.edu/",
1013
1013
                                            p_prefix));
1014
1014
                       }
1015
 
 
 
1015
                      
1016
1016
 
1017
1017
                   if (!_rebootInstancesType->is_valid_statusMessage)
1018
1018
                   {
1019
 
 
 
1019
                      
1020
1020
                           /* no need to complain for minoccurs=0 element */
1021
 
 
1022
 
 
 
1021
                            
 
1022
                          
1023
1023
                   }
1024
1024
                   else
1025
1025
                   {
1026
1026
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1027
 
                                 (4 + axutil_strlen(p_prefix) +
1028
 
                                  axutil_strlen("statusMessage")));
1029
 
 
 
1027
                                 (4 + axutil_strlen(p_prefix) + 
 
1028
                                  axutil_strlen("statusMessage"))); 
 
1029
                                 
1030
1030
                                 /* axutil_strlen("<:>") + 1 = 4 */
1031
1031
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1032
1032
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1033
1033
                                  /* axutil_strlen("</:>") + 1 = 5 */
1034
 
 
1035
 
 
1036
 
 
1037
 
 
1038
 
 
1039
 
 
 
1034
                                  
 
1035
                     
 
1036
 
 
1037
                   
 
1038
                   
 
1039
                     
1040
1040
                     /*
1041
1041
                      * parsing statusMessage element
1042
1042
                      */
1043
1043
 
1044
 
 
1045
 
 
 
1044
                    
 
1045
                    
1046
1046
                            sprintf(start_input_str, "<%s%sstatusMessage>",
1047
1047
                                 p_prefix?p_prefix:"",
1048
1048
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1049
 
 
 
1049
                            
1050
1050
                        start_input_str_len = axutil_strlen(start_input_str);
1051
1051
                        sprintf(end_input_str, "</%s%sstatusMessage>",
1052
1052
                                 p_prefix?p_prefix:"",
1053
1053
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1054
1054
                        end_input_str_len = axutil_strlen(end_input_str);
1055
 
 
 
1055
                    
1056
1056
                           text_value_3 = _rebootInstancesType->property_statusMessage;
1057
 
 
 
1057
                           
1058
1058
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1059
 
 
1060
 
 
 
1059
                           
 
1060
                            
1061
1061
                           text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1062
1062
                           if (text_value_3_temp)
1063
1063
                           {
1068
1068
                           {
1069
1069
                               axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1070
1070
                           }
1071
 
 
 
1071
                           
1072
1072
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1073
 
 
1074
 
 
 
1073
                           
 
1074
                     
1075
1075
                     AXIS2_FREE(env->allocator,start_input_str);
1076
1076
                     AXIS2_FREE(env->allocator,end_input_str);
1077
 
                 }
1078
 
 
1079
 
 
 
1077
                 } 
 
1078
 
 
1079
                 
1080
1080
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1081
1081
                       {
1082
1082
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1083
1083
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1084
1084
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1085
 
 
 
1085
                           
1086
1086
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1087
1087
                                            "http://eucalyptus.ucsb.edu/",
1088
1088
                                            p_prefix));
1089
1089
                       }
1090
 
 
 
1090
                      
1091
1091
 
1092
1092
                   if (!_rebootInstancesType->is_valid_return)
1093
1093
                   {
1094
 
 
 
1094
                      
1095
1095
                           /* no need to complain for minoccurs=0 element */
1096
 
 
1097
 
 
 
1096
                            
 
1097
                          
1098
1098
                   }
1099
1099
                   else
1100
1100
                   {
1101
1101
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1102
 
                                 (4 + axutil_strlen(p_prefix) +
1103
 
                                  axutil_strlen("return")));
1104
 
 
 
1102
                                 (4 + axutil_strlen(p_prefix) + 
 
1103
                                  axutil_strlen("return"))); 
 
1104
                                 
1105
1105
                                 /* axutil_strlen("<:>") + 1 = 4 */
1106
1106
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1107
1107
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1108
1108
                                  /* axutil_strlen("</:>") + 1 = 5 */
1109
 
 
1110
 
 
1111
 
 
1112
 
 
1113
 
 
1114
 
 
 
1109
                                  
 
1110
                     
 
1111
 
 
1112
                   
 
1113
                   
 
1114
                     
1115
1115
                     /*
1116
1116
                      * parsing return element
1117
1117
                      */
1118
1118
 
1119
 
 
1120
 
 
 
1119
                    
 
1120
                    
1121
1121
                            sprintf(start_input_str, "<%s%sreturn>",
1122
1122
                                 p_prefix?p_prefix:"",
1123
1123
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1124
 
 
 
1124
                            
1125
1125
                        start_input_str_len = axutil_strlen(start_input_str);
1126
1126
                        sprintf(end_input_str, "</%s%sreturn>",
1127
1127
                                 p_prefix?p_prefix:"",
1128
1128
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1129
1129
                        end_input_str_len = axutil_strlen(end_input_str);
1130
 
 
 
1130
                    
1131
1131
                           strcpy(text_value_4, (_rebootInstancesType->property_return)?"true":"false");
1132
 
 
 
1132
                           
1133
1133
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1134
 
 
 
1134
                           
1135
1135
                           axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1136
 
 
 
1136
                           
1137
1137
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1138
 
 
1139
 
 
 
1138
                           
 
1139
                     
1140
1140
                     AXIS2_FREE(env->allocator,start_input_str);
1141
1141
                     AXIS2_FREE(env->allocator,end_input_str);
1142
 
                 }
1143
 
 
1144
 
 
 
1142
                 } 
 
1143
 
 
1144
                 
1145
1145
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1146
1146
                       {
1147
1147
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1148
1148
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1149
1149
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1150
 
 
 
1150
                           
1151
1151
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1152
1152
                                            "http://eucalyptus.ucsb.edu/",
1153
1153
                                            p_prefix));
1154
1154
                       }
1155
 
 
 
1155
                      
1156
1156
 
1157
1157
                   if (!_rebootInstancesType->is_valid_instanceIds)
1158
1158
                   {
1159
 
 
 
1159
                      
1160
1160
                           /* no need to complain for minoccurs=0 element */
1161
 
 
1162
 
 
 
1161
                            
 
1162
                          
1163
1163
                   }
1164
1164
                   else
1165
1165
                   {
1166
1166
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1167
 
                                 (4 + axutil_strlen(p_prefix) +
1168
 
                                  axutil_strlen("instanceIds")));
1169
 
 
 
1167
                                 (4 + axutil_strlen(p_prefix) + 
 
1168
                                  axutil_strlen("instanceIds"))); 
 
1169
                                 
1170
1170
                                 /* axutil_strlen("<:>") + 1 = 4 */
1171
1171
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1172
1172
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("instanceIds")));
1173
1173
                                  /* axutil_strlen("</:>") + 1 = 5 */
1174
 
 
1175
 
 
1176
 
 
1177
 
 
1178
 
 
 
1174
                                  
 
1175
                     
 
1176
 
 
1177
                   
 
1178
                   
1179
1179
                     /*
1180
1180
                      * Parsing instanceIds array
1181
1181
                      */
1182
1182
                     if (_rebootInstancesType->property_instanceIds != NULL)
1183
1183
                     {
1184
 
 
 
1184
                        
1185
1185
                            sprintf(start_input_str, "<%s%sinstanceIds>",
1186
1186
                                 p_prefix?p_prefix:"",
1187
 
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1188
 
 
 
1187
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); 
 
1188
                            
1189
1189
                         start_input_str_len = axutil_strlen(start_input_str);
1190
1190
 
1191
1191
                         sprintf(end_input_str, "</%s%sinstanceIds>",
1198
1198
                         {
1199
1199
                            element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1200
1200
 
1201
 
                            if(NULL == element)
 
1201
                            if(NULL == element) 
1202
1202
                            {
1203
1203
                                continue;
1204
1204
                            }
1205
 
 
1206
 
 
 
1205
                    
 
1206
                     
1207
1207
                     /*
1208
1208
                      * parsing instanceIds element
1209
1209
                      */
1210
1210
 
1211
 
 
1212
 
 
 
1211
                    
 
1212
                    
1213
1213
                           text_value_5 = (axis2_char_t*)element;
1214
 
 
 
1214
                           
1215
1215
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1216
 
 
1217
 
 
 
1216
                           
 
1217
                            
1218
1218
                           text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1219
1219
                           if (text_value_5_temp)
1220
1220
                           {
1225
1225
                           {
1226
1226
                               axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1227
1227
                           }
1228
 
 
 
1228
                           
1229
1229
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1230
 
 
 
1230
                           
1231
1231
                         }
1232
1232
                     }
1233
 
 
1234
 
 
 
1233
                   
 
1234
                     
1235
1235
                     AXIS2_FREE(env->allocator,start_input_str);
1236
1236
                     AXIS2_FREE(env->allocator,end_input_str);
1237
 
                 }
1238
 
 
1239
 
 
 
1237
                 } 
 
1238
 
 
1239
                 
1240
1240
 
1241
1241
            return parent;
1242
1242
        }
1243
1243
 
1244
1244
 
1245
 
 
 
1245
        
1246
1246
 
1247
1247
            /**
1248
1248
             * getter for correlationId.
1252
1252
                    adb_rebootInstancesType_t* _rebootInstancesType,
1253
1253
                    const axutil_env_t *env)
1254
1254
             {
1255
 
 
 
1255
                
1256
1256
                    AXIS2_ENV_CHECK(env, NULL);
1257
1257
                    AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1258
 
 
 
1258
                  
1259
1259
 
1260
1260
                return _rebootInstancesType->property_correlationId;
1261
1261
             }
1269
1269
                    const axutil_env_t *env,
1270
1270
                    const axis2_char_t*  arg_correlationId)
1271
1271
             {
1272
 
 
 
1272
                
1273
1273
 
1274
1274
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1275
1275
                AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1276
 
 
 
1276
                
1277
1277
                if(_rebootInstancesType->is_valid_correlationId &&
1278
1278
                        arg_correlationId == _rebootInstancesType->property_correlationId)
1279
1279
                {
1280
 
 
1281
 
                    return AXIS2_SUCCESS;
 
1280
                    
 
1281
                    return AXIS2_SUCCESS; 
1282
1282
                }
1283
1283
 
1284
1284
                adb_rebootInstancesType_reset_correlationId(_rebootInstancesType, env);
1285
1285
 
1286
 
 
 
1286
                
1287
1287
                if(NULL == arg_correlationId)
1288
1288
                {
1289
1289
                    /* We are already done */
1296
1296
                            return AXIS2_FAILURE;
1297
1297
                        }
1298
1298
                        _rebootInstancesType->is_valid_correlationId = AXIS2_TRUE;
1299
 
 
 
1299
                    
1300
1300
                return AXIS2_SUCCESS;
1301
1301
             }
1302
1302
 
1303
 
 
 
1303
             
1304
1304
 
1305
1305
           /**
1306
1306
            * resetter for correlationId
1316
1316
 
1317
1317
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1318
1318
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1319
 
 
1320
 
 
1321
 
 
1322
 
 
1323
 
 
 
1319
               
 
1320
 
 
1321
               
 
1322
            
 
1323
                
1324
1324
                if(_rebootInstancesType->property_correlationId != NULL)
1325
1325
                {
1326
 
 
1327
 
 
 
1326
                   
 
1327
                   
1328
1328
                        AXIS2_FREE(env-> allocator, _rebootInstancesType->property_correlationId);
1329
1329
                     _rebootInstancesType->property_correlationId = NULL;
1330
1330
                }
1331
 
 
1332
 
 
1333
 
 
1334
 
                _rebootInstancesType->is_valid_correlationId = AXIS2_FALSE;
 
1331
            
 
1332
                
 
1333
                
 
1334
                _rebootInstancesType->is_valid_correlationId = AXIS2_FALSE; 
1335
1335
               return AXIS2_SUCCESS;
1336
1336
           }
1337
1337
 
1345
1345
           {
1346
1346
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1347
1347
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1348
 
 
 
1348
               
1349
1349
               return !_rebootInstancesType->is_valid_correlationId;
1350
1350
           }
1351
1351
 
1360
1360
               return adb_rebootInstancesType_reset_correlationId(_rebootInstancesType, env);
1361
1361
           }
1362
1362
 
1363
 
 
 
1363
           
1364
1364
 
1365
1365
            /**
1366
1366
             * getter for userId.
1370
1370
                    adb_rebootInstancesType_t* _rebootInstancesType,
1371
1371
                    const axutil_env_t *env)
1372
1372
             {
1373
 
 
 
1373
                
1374
1374
                    AXIS2_ENV_CHECK(env, NULL);
1375
1375
                    AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1376
 
 
 
1376
                  
1377
1377
 
1378
1378
                return _rebootInstancesType->property_userId;
1379
1379
             }
1387
1387
                    const axutil_env_t *env,
1388
1388
                    const axis2_char_t*  arg_userId)
1389
1389
             {
1390
 
 
 
1390
                
1391
1391
 
1392
1392
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1393
1393
                AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1394
 
 
 
1394
                
1395
1395
                if(_rebootInstancesType->is_valid_userId &&
1396
1396
                        arg_userId == _rebootInstancesType->property_userId)
1397
1397
                {
1398
 
 
1399
 
                    return AXIS2_SUCCESS;
 
1398
                    
 
1399
                    return AXIS2_SUCCESS; 
1400
1400
                }
1401
1401
 
1402
1402
                adb_rebootInstancesType_reset_userId(_rebootInstancesType, env);
1403
1403
 
1404
 
 
 
1404
                
1405
1405
                if(NULL == arg_userId)
1406
1406
                {
1407
1407
                    /* We are already done */
1414
1414
                            return AXIS2_FAILURE;
1415
1415
                        }
1416
1416
                        _rebootInstancesType->is_valid_userId = AXIS2_TRUE;
1417
 
 
 
1417
                    
1418
1418
                return AXIS2_SUCCESS;
1419
1419
             }
1420
1420
 
1421
 
 
 
1421
             
1422
1422
 
1423
1423
           /**
1424
1424
            * resetter for userId
1434
1434
 
1435
1435
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1436
1436
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1437
 
 
1438
 
 
1439
 
 
1440
 
 
1441
 
 
 
1437
               
 
1438
 
 
1439
               
 
1440
            
 
1441
                
1442
1442
                if(_rebootInstancesType->property_userId != NULL)
1443
1443
                {
1444
 
 
1445
 
 
 
1444
                   
 
1445
                   
1446
1446
                        AXIS2_FREE(env-> allocator, _rebootInstancesType->property_userId);
1447
1447
                     _rebootInstancesType->property_userId = NULL;
1448
1448
                }
1449
 
 
1450
 
 
1451
 
 
1452
 
                _rebootInstancesType->is_valid_userId = AXIS2_FALSE;
 
1449
            
 
1450
                
 
1451
                
 
1452
                _rebootInstancesType->is_valid_userId = AXIS2_FALSE; 
1453
1453
               return AXIS2_SUCCESS;
1454
1454
           }
1455
1455
 
1463
1463
           {
1464
1464
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1465
1465
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1466
 
 
 
1466
               
1467
1467
               return !_rebootInstancesType->is_valid_userId;
1468
1468
           }
1469
1469
 
1478
1478
               return adb_rebootInstancesType_reset_userId(_rebootInstancesType, env);
1479
1479
           }
1480
1480
 
1481
 
 
 
1481
           
1482
1482
 
1483
1483
            /**
1484
1484
             * getter for statusMessage.
1488
1488
                    adb_rebootInstancesType_t* _rebootInstancesType,
1489
1489
                    const axutil_env_t *env)
1490
1490
             {
1491
 
 
 
1491
                
1492
1492
                    AXIS2_ENV_CHECK(env, NULL);
1493
1493
                    AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1494
 
 
 
1494
                  
1495
1495
 
1496
1496
                return _rebootInstancesType->property_statusMessage;
1497
1497
             }
1505
1505
                    const axutil_env_t *env,
1506
1506
                    const axis2_char_t*  arg_statusMessage)
1507
1507
             {
1508
 
 
 
1508
                
1509
1509
 
1510
1510
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1511
1511
                AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1512
 
 
 
1512
                
1513
1513
                if(_rebootInstancesType->is_valid_statusMessage &&
1514
1514
                        arg_statusMessage == _rebootInstancesType->property_statusMessage)
1515
1515
                {
1516
 
 
1517
 
                    return AXIS2_SUCCESS;
 
1516
                    
 
1517
                    return AXIS2_SUCCESS; 
1518
1518
                }
1519
1519
 
1520
1520
                adb_rebootInstancesType_reset_statusMessage(_rebootInstancesType, env);
1521
1521
 
1522
 
 
 
1522
                
1523
1523
                if(NULL == arg_statusMessage)
1524
1524
                {
1525
1525
                    /* We are already done */
1532
1532
                            return AXIS2_FAILURE;
1533
1533
                        }
1534
1534
                        _rebootInstancesType->is_valid_statusMessage = AXIS2_TRUE;
1535
 
 
 
1535
                    
1536
1536
                return AXIS2_SUCCESS;
1537
1537
             }
1538
1538
 
1539
 
 
 
1539
             
1540
1540
 
1541
1541
           /**
1542
1542
            * resetter for statusMessage
1552
1552
 
1553
1553
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1554
1554
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1555
 
 
1556
 
 
1557
 
 
1558
 
 
1559
 
 
 
1555
               
 
1556
 
 
1557
               
 
1558
            
 
1559
                
1560
1560
                if(_rebootInstancesType->property_statusMessage != NULL)
1561
1561
                {
1562
 
 
1563
 
 
 
1562
                   
 
1563
                   
1564
1564
                        AXIS2_FREE(env-> allocator, _rebootInstancesType->property_statusMessage);
1565
1565
                     _rebootInstancesType->property_statusMessage = NULL;
1566
1566
                }
1567
 
 
1568
 
 
1569
 
 
1570
 
                _rebootInstancesType->is_valid_statusMessage = AXIS2_FALSE;
 
1567
            
 
1568
                
 
1569
                
 
1570
                _rebootInstancesType->is_valid_statusMessage = AXIS2_FALSE; 
1571
1571
               return AXIS2_SUCCESS;
1572
1572
           }
1573
1573
 
1581
1581
           {
1582
1582
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1583
1583
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1584
 
 
 
1584
               
1585
1585
               return !_rebootInstancesType->is_valid_statusMessage;
1586
1586
           }
1587
1587
 
1596
1596
               return adb_rebootInstancesType_reset_statusMessage(_rebootInstancesType, env);
1597
1597
           }
1598
1598
 
1599
 
 
 
1599
           
1600
1600
 
1601
1601
            /**
1602
1602
             * getter for return.
1606
1606
                    adb_rebootInstancesType_t* _rebootInstancesType,
1607
1607
                    const axutil_env_t *env)
1608
1608
             {
1609
 
 
 
1609
                
1610
1610
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1611
1611
                    AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, (axis2_bool_t)0);
1612
 
 
 
1612
                  
1613
1613
 
1614
1614
                return _rebootInstancesType->property_return;
1615
1615
             }
1623
1623
                    const axutil_env_t *env,
1624
1624
                    axis2_bool_t  arg_return)
1625
1625
             {
1626
 
 
 
1626
                
1627
1627
 
1628
1628
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1629
1629
                AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1630
 
 
 
1630
                
1631
1631
                if(_rebootInstancesType->is_valid_return &&
1632
1632
                        arg_return == _rebootInstancesType->property_return)
1633
1633
                {
1634
 
 
1635
 
                    return AXIS2_SUCCESS;
 
1634
                    
 
1635
                    return AXIS2_SUCCESS; 
1636
1636
                }
1637
1637
 
1638
1638
                adb_rebootInstancesType_reset_return(_rebootInstancesType, env);
1639
1639
 
1640
1640
                _rebootInstancesType->property_return = arg_return;
1641
1641
                        _rebootInstancesType->is_valid_return = AXIS2_TRUE;
1642
 
 
 
1642
                    
1643
1643
                return AXIS2_SUCCESS;
1644
1644
             }
1645
1645
 
1646
 
 
 
1646
             
1647
1647
 
1648
1648
           /**
1649
1649
            * resetter for return
1659
1659
 
1660
1660
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1661
1661
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1662
 
 
1663
 
 
1664
 
               _rebootInstancesType->is_valid_return = AXIS2_FALSE;
 
1662
               
 
1663
 
 
1664
               _rebootInstancesType->is_valid_return = AXIS2_FALSE; 
1665
1665
               return AXIS2_SUCCESS;
1666
1666
           }
1667
1667
 
1675
1675
           {
1676
1676
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1677
1677
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
1678
 
 
 
1678
               
1679
1679
               return !_rebootInstancesType->is_valid_return;
1680
1680
           }
1681
1681
 
1690
1690
               return adb_rebootInstancesType_reset_return(_rebootInstancesType, env);
1691
1691
           }
1692
1692
 
1693
 
 
 
1693
           
1694
1694
 
1695
1695
            /**
1696
1696
             * getter for instanceIds.
1700
1700
                    adb_rebootInstancesType_t* _rebootInstancesType,
1701
1701
                    const axutil_env_t *env)
1702
1702
             {
1703
 
 
 
1703
                
1704
1704
                    AXIS2_ENV_CHECK(env, NULL);
1705
1705
                    AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1706
 
 
 
1706
                  
1707
1707
 
1708
1708
                return _rebootInstancesType->property_instanceIds;
1709
1709
             }
1717
1717
                    const axutil_env_t *env,
1718
1718
                    axutil_array_list_t*  arg_instanceIds)
1719
1719
             {
1720
 
 
 
1720
                
1721
1721
                 int size = 0;
1722
1722
                 int i = 0;
1723
1723
                 axis2_bool_t non_nil_exists = AXIS2_FALSE;
1724
 
 
 
1724
                
1725
1725
 
1726
1726
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1727
1727
                AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1728
 
 
 
1728
                
1729
1729
                if(_rebootInstancesType->is_valid_instanceIds &&
1730
1730
                        arg_instanceIds == _rebootInstancesType->property_instanceIds)
1731
1731
                {
1732
 
 
1733
 
                    return AXIS2_SUCCESS;
 
1732
                    
 
1733
                    return AXIS2_SUCCESS; 
1734
1734
                }
1735
1735
 
1736
 
 
 
1736
                
1737
1737
                 size = axutil_array_list_size(arg_instanceIds, env);
1738
 
 
 
1738
                 
1739
1739
                 if (size < 0)
1740
1740
                 {
1741
1741
                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "instanceIds has less than minOccurs(0)");
1752
1752
 
1753
1753
                 adb_rebootInstancesType_reset_instanceIds(_rebootInstancesType, env);
1754
1754
 
1755
 
 
 
1755
                
1756
1756
                if(NULL == arg_instanceIds)
1757
1757
                {
1758
1758
                    /* We are already done */
1763
1763
                        {
1764
1764
                            _rebootInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1765
1765
                        }
1766
 
 
1767
 
 
 
1766
                        
 
1767
                    
1768
1768
                return AXIS2_SUCCESS;
1769
1769
             }
1770
1770
 
1771
 
 
 
1771
            
1772
1772
            /**
1773
1773
             * Get ith element of instanceIds.
1774
1774
             */
1779
1779
            {
1780
1780
                axis2_char_t* ret_val;
1781
1781
 
1782
 
 
 
1782
                
1783
1783
                    AXIS2_ENV_CHECK(env, NULL);
1784
1784
                    AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, NULL);
1785
 
 
 
1785
                  
1786
1786
 
1787
1787
                if(_rebootInstancesType->property_instanceIds == NULL)
1788
1788
                {
1789
1789
                    return (axis2_char_t*)0;
1790
1790
                }
1791
1791
                ret_val = (axis2_char_t*)axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1792
 
 
 
1792
                
1793
1793
                    return ret_val;
1794
 
 
 
1794
                  
1795
1795
            }
1796
1796
 
1797
1797
            /**
1809
1809
                int k;
1810
1810
                axis2_bool_t non_nil_exists = AXIS2_FALSE;
1811
1811
 
1812
 
 
 
1812
                
1813
1813
 
1814
1814
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1815
1815
                AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1816
 
 
 
1816
                
1817
1817
                if( _rebootInstancesType->is_valid_instanceIds &&
1818
1818
                    _rebootInstancesType->property_instanceIds &&
1819
 
 
 
1819
                
1820
1820
                    arg_instanceIds == (axis2_char_t*)axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i))
1821
 
 
 
1821
                  
1822
1822
                {
1823
 
 
1824
 
                    return AXIS2_SUCCESS;
 
1823
                    
 
1824
                    return AXIS2_SUCCESS; 
1825
1825
                }
1826
1826
 
1827
 
 
 
1827
                
1828
1828
                    if(NULL == arg_instanceIds)
1829
1829
                    {
1830
1830
                        if(_rebootInstancesType->property_instanceIds != NULL)
1832
1832
                            size = axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
1833
1833
                            for(j = 0, k = 0; j < size; j ++ )
1834
1834
                            {
1835
 
                                if(i == j) continue;
 
1835
                                if(i == j) continue; 
1836
1836
                                if(NULL != axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i))
1837
1837
                                {
1838
1838
                                    k ++;
1849
1849
                    {
1850
1850
                        non_nil_exists = AXIS2_TRUE;
1851
1851
                    }
1852
 
 
 
1852
                  
1853
1853
                if( k < 0)
1854
1854
                {
1855
1855
                       AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of instanceIds is beinng set to be smaller than the specificed number of minOccurs(0)");
1860
1860
                {
1861
1861
                    _rebootInstancesType->property_instanceIds = axutil_array_list_create(env, 10);
1862
1862
                }
1863
 
 
 
1863
                
1864
1864
                /* check whether there already exist an element */
1865
1865
                element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1866
1866
                if(NULL != element)
1867
1867
                {
1868
 
 
1869
 
 
1870
 
 
 
1868
                  
 
1869
                  
 
1870
                  
1871
1871
                       /* This is an unknown type or a primitive. Please free this manually*/
1872
 
 
 
1872
                     
1873
1873
                }
1874
1874
 
1875
 
 
 
1875
                
1876
1876
                    if(!non_nil_exists)
1877
1877
                    {
1878
 
 
 
1878
                        
1879
1879
                        _rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
1880
1880
                        axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, NULL);
1881
 
 
 
1881
                        
1882
1882
                        return AXIS2_SUCCESS;
1883
1883
                    }
1884
 
 
 
1884
                
1885
1885
                   axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, axutil_strdup(env, arg_instanceIds));
1886
1886
                  _rebootInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1887
 
 
 
1887
                
1888
1888
                return AXIS2_SUCCESS;
1889
1889
            }
1890
1890
 
1897
1897
                    const axutil_env_t *env,
1898
1898
                    const axis2_char_t* arg_instanceIds)
1899
1899
             {
1900
 
 
 
1900
                
1901
1901
 
1902
1902
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1903
1903
                AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1904
1904
 
1905
 
 
 
1905
                
1906
1906
                    if(NULL == arg_instanceIds)
1907
1907
                    {
1908
 
 
1909
 
                           return AXIS2_SUCCESS;
1910
 
 
 
1908
                      
 
1909
                           return AXIS2_SUCCESS; 
 
1910
                        
1911
1911
                    }
1912
 
 
 
1912
                  
1913
1913
 
1914
1914
                if(_rebootInstancesType->property_instanceIds == NULL)
1915
1915
                {
1919
1919
                {
1920
1920
                    AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed in allocatting memory for instanceIds");
1921
1921
                    return AXIS2_FAILURE;
1922
 
 
 
1922
                    
1923
1923
                }
1924
 
 
 
1924
                
1925
1925
                   axutil_array_list_add(_rebootInstancesType->property_instanceIds , env, axutil_strdup(env, arg_instanceIds));
1926
1926
                  _rebootInstancesType->is_valid_instanceIds = AXIS2_TRUE;
1927
1927
                return AXIS2_SUCCESS;
1955
1955
                return adb_rebootInstancesType_set_instanceIds_nil_at(_rebootInstancesType, env, i);
1956
1956
            }
1957
1957
 
1958
 
 
 
1958
            
1959
1959
 
1960
1960
           /**
1961
1961
            * resetter for instanceIds
1971
1971
 
1972
1972
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1973
1973
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_FAILURE);
1974
 
 
1975
 
 
1976
 
 
 
1974
               
 
1975
 
 
1976
               
1977
1977
                  if (_rebootInstancesType->property_instanceIds != NULL)
1978
1978
                  {
1979
1979
                      count = axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
1980
1980
                      for(i = 0; i < count; i ++)
1981
1981
                      {
1982
1982
                         element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
1983
 
 
1984
 
 
1985
 
 
 
1983
                
 
1984
            
 
1985
                
1986
1986
                if(element != NULL)
1987
1987
                {
1988
 
 
1989
 
 
 
1988
                   
 
1989
                   
1990
1990
                        AXIS2_FREE(env-> allocator, (axis2_char_t*)element);
1991
1991
                     element = NULL;
1992
1992
                }
1993
 
 
1994
 
 
1995
 
 
1996
 
 
 
1993
            
 
1994
                
 
1995
                
 
1996
                
1997
1997
                      }
1998
1998
                      axutil_array_list_free(_rebootInstancesType->property_instanceIds, env);
1999
1999
                  }
2000
 
                _rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
 
2000
                _rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE; 
2001
2001
               return AXIS2_SUCCESS;
2002
2002
           }
2003
2003
 
2011
2011
           {
2012
2012
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2013
2013
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
2014
 
 
 
2014
               
2015
2015
               return !_rebootInstancesType->is_valid_instanceIds;
2016
2016
           }
2017
2017
 
2026
2026
               return adb_rebootInstancesType_reset_instanceIds(_rebootInstancesType, env);
2027
2027
           }
2028
2028
 
2029
 
 
 
2029
           
2030
2030
           /**
2031
2031
            * Check whether instanceIds is nill at i
2032
2032
            */
2037
2037
           {
2038
2038
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2039
2039
               AXIS2_PARAM_CHECK(env->error, _rebootInstancesType, AXIS2_TRUE);
2040
 
 
 
2040
               
2041
2041
               return (_rebootInstancesType->is_valid_instanceIds == AXIS2_FALSE ||
2042
 
                        NULL == _rebootInstancesType->property_instanceIds ||
 
2042
                        NULL == _rebootInstancesType->property_instanceIds || 
2043
2043
                        NULL == axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i));
2044
2044
           }
2045
2045
 
2064
2064
                if(_rebootInstancesType->property_instanceIds == NULL ||
2065
2065
                            _rebootInstancesType->is_valid_instanceIds == AXIS2_FALSE)
2066
2066
                {
2067
 
 
 
2067
                    
2068
2068
                    non_nil_exists = AXIS2_FALSE;
2069
2069
                }
2070
2070
                else
2072
2072
                    size = axutil_array_list_size(_rebootInstancesType->property_instanceIds, env);
2073
2073
                    for(j = 0, k = 0; j < size; j ++ )
2074
2074
                    {
2075
 
                        if(i == j) continue;
 
2075
                        if(i == j) continue; 
2076
2076
                        if(NULL != axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i))
2077
2077
                        {
2078
2078
                            k ++;
2084
2084
                        }
2085
2085
                    }
2086
2086
                }
2087
 
 
 
2087
                
2088
2088
 
2089
2089
                if( k < 0)
2090
2090
                {
2091
2091
                       AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Size of the array of instanceIds is beinng set to be smaller than the specificed number of minOccurs(0)");
2092
2092
                       return AXIS2_FAILURE;
2093
2093
                }
2094
 
 
 
2094
 
2095
2095
                if(_rebootInstancesType->property_instanceIds == NULL)
2096
2096
                {
2097
2097
                    _rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2098
 
 
 
2098
                    
2099
2099
                    return AXIS2_SUCCESS;
2100
2100
                }
2101
2101
 
2103
2103
                element = axutil_array_list_get(_rebootInstancesType->property_instanceIds, env, i);
2104
2104
                if(NULL != element)
2105
2105
                {
2106
 
 
2107
 
 
2108
 
 
 
2106
                  
 
2107
                  
 
2108
                  
2109
2109
                       /* This is an unknown type or a primitive. Please free this manually*/
2110
 
 
 
2110
                     
2111
2111
                }
2112
2112
 
2113
 
 
 
2113
                
2114
2114
                    if(!non_nil_exists)
2115
2115
                    {
2116
 
 
 
2116
                        
2117
2117
                        _rebootInstancesType->is_valid_instanceIds = AXIS2_FALSE;
2118
2118
                        axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, NULL);
2119
2119
                        return AXIS2_SUCCESS;
2120
2120
                    }
2121
 
 
2122
 
 
2123
 
 
 
2121
                
 
2122
 
 
2123
                
2124
2124
                axutil_array_list_set(_rebootInstancesType->property_instanceIds , env, i, NULL);
2125
 
 
 
2125
                
2126
2126
                return AXIS2_SUCCESS;
2127
2127
 
2128
2128
           }
2129
2129
 
2130
 
 
 
2130
           
2131
2131