← Back to branch summary

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

« back to all changes in this revision

Viewing changes to node/generated/adb_ncDescribeResourceResponseType.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:
node/generated/adb_ncDescribeResourceResponseType.c
8
8
         */
9
9
 
10
10
        #include "adb_ncDescribeResourceResponseType.h"
11
 
 
 
11
        
12
12
                /*
13
13
                 * This type was generated from the piece of schema that had
14
14
                 * name = ncDescribeResourceResponseType
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_ncDescribeResourceResponseType
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_bool_t property_return;
36
36
 
37
 
 
 
37
                
38
38
                axis2_bool_t is_valid_return;
39
39
 
40
40
 
 
41
            axis2_char_t* property_nodeName;
 
42
 
 
43
                
 
44
                axis2_bool_t is_valid_nodeName;
 
45
 
 
46
 
41
47
            int property_statusMessage;
42
48
 
43
 
 
 
49
                
44
50
                axis2_bool_t is_valid_statusMessage;
45
51
 
46
52
 
47
53
            axis2_char_t* property_nodeStatus;
48
54
 
49
 
 
 
55
                
50
56
                axis2_bool_t is_valid_nodeStatus;
51
57
 
52
58
 
53
59
            int property_memorySizeMax;
54
60
 
55
 
 
 
61
                
56
62
                axis2_bool_t is_valid_memorySizeMax;
57
63
 
58
64
 
59
65
            int property_memorySizeAvailable;
60
66
 
61
 
 
 
67
                
62
68
                axis2_bool_t is_valid_memorySizeAvailable;
63
69
 
64
70
 
65
71
            int property_diskSizeMax;
66
72
 
67
 
 
 
73
                
68
74
                axis2_bool_t is_valid_diskSizeMax;
69
75
 
70
76
 
71
77
            int property_diskSizeAvailable;
72
78
 
73
 
 
 
79
                
74
80
                axis2_bool_t is_valid_diskSizeAvailable;
75
81
 
76
82
 
77
83
            int property_numberOfCoresMax;
78
84
 
79
 
 
 
85
                
80
86
                axis2_bool_t is_valid_numberOfCoresMax;
81
87
 
82
88
 
83
89
            int property_numberOfCoresAvailable;
84
90
 
85
 
 
 
91
                
86
92
                axis2_bool_t is_valid_numberOfCoresAvailable;
87
93
 
88
94
 
89
95
            axis2_char_t* property_publicSubnets;
90
96
 
91
 
 
 
97
                
92
98
                axis2_bool_t is_valid_publicSubnets;
93
99
 
94
100
 
95
 
 
 
101
            
96
102
        };
97
103
 
98
104
 
99
105
       /************************* Private Function prototypes ********************************/
100
 
 
101
 
 
102
 
                axis2_status_t AXIS2_CALL
103
 
                adb_ncDescribeResourceResponseType_set_correlationId_nil(
104
 
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
105
 
                        const axutil_env_t *env);
106
 
 
 
106
        
107
107
 
108
108
                axis2_status_t AXIS2_CALL
109
109
                adb_ncDescribeResourceResponseType_set_userId_nil(
110
110
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
111
111
                        const axutil_env_t *env);
112
 
 
 
112
            
113
113
 
114
114
                axis2_status_t AXIS2_CALL
115
115
                adb_ncDescribeResourceResponseType_set_return_nil(
116
116
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
117
117
                        const axutil_env_t *env);
118
 
 
 
118
            
119
119
 
120
120
                axis2_status_t AXIS2_CALL
121
121
                adb_ncDescribeResourceResponseType_set_nodeStatus_nil(
122
122
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
123
123
                        const axutil_env_t *env);
124
 
 
 
124
            
125
125
 
126
126
                axis2_status_t AXIS2_CALL
127
127
                adb_ncDescribeResourceResponseType_set_memorySizeMax_nil(
128
128
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
129
129
                        const axutil_env_t *env);
130
 
 
 
130
            
131
131
 
132
132
                axis2_status_t AXIS2_CALL
133
133
                adb_ncDescribeResourceResponseType_set_memorySizeAvailable_nil(
134
134
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
135
135
                        const axutil_env_t *env);
136
 
 
 
136
            
137
137
 
138
138
                axis2_status_t AXIS2_CALL
139
139
                adb_ncDescribeResourceResponseType_set_diskSizeMax_nil(
140
140
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
141
141
                        const axutil_env_t *env);
142
 
 
 
142
            
143
143
 
144
144
                axis2_status_t AXIS2_CALL
145
145
                adb_ncDescribeResourceResponseType_set_diskSizeAvailable_nil(
146
146
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
147
147
                        const axutil_env_t *env);
148
 
 
 
148
            
149
149
 
150
150
                axis2_status_t AXIS2_CALL
151
151
                adb_ncDescribeResourceResponseType_set_numberOfCoresMax_nil(
152
152
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
153
153
                        const axutil_env_t *env);
154
 
 
 
154
            
155
155
 
156
156
                axis2_status_t AXIS2_CALL
157
157
                adb_ncDescribeResourceResponseType_set_numberOfCoresAvailable_nil(
158
158
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
159
159
                        const axutil_env_t *env);
160
 
 
 
160
            
161
161
 
162
162
                axis2_status_t AXIS2_CALL
163
163
                adb_ncDescribeResourceResponseType_set_publicSubnets_nil(
164
164
                        adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
165
165
                        const axutil_env_t *env);
166
 
 
 
166
            
167
167
 
168
168
 
169
169
       /************************* Function Implmentations ********************************/
172
172
            const axutil_env_t *env)
173
173
        {
174
174
            adb_ncDescribeResourceResponseType_t *_ncDescribeResourceResponseType = NULL;
175
 
 
 
175
            
176
176
            AXIS2_ENV_CHECK(env, NULL);
177
177
 
178
178
            _ncDescribeResourceResponseType = (adb_ncDescribeResourceResponseType_t *) AXIS2_MALLOC(env->
191
191
            _ncDescribeResourceResponseType->property_userId  = NULL;
192
192
                  _ncDescribeResourceResponseType->is_valid_userId  = AXIS2_FALSE;
193
193
            _ncDescribeResourceResponseType->is_valid_return  = AXIS2_FALSE;
 
194
            _ncDescribeResourceResponseType->property_nodeName  = NULL;
 
195
                  _ncDescribeResourceResponseType->is_valid_nodeName  = AXIS2_FALSE;
194
196
            _ncDescribeResourceResponseType->is_valid_statusMessage  = AXIS2_FALSE;
195
197
            _ncDescribeResourceResponseType->property_nodeStatus  = NULL;
196
198
                  _ncDescribeResourceResponseType->is_valid_nodeStatus  = AXIS2_FALSE;
202
204
            _ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable  = AXIS2_FALSE;
203
205
            _ncDescribeResourceResponseType->property_publicSubnets  = NULL;
204
206
                  _ncDescribeResourceResponseType->is_valid_publicSubnets  = AXIS2_FALSE;
205
 
 
 
207
            
206
208
 
207
209
            return _ncDescribeResourceResponseType;
208
210
        }
212
214
                adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
213
215
                const axutil_env_t *env)
214
216
        {
215
 
 
 
217
            
216
218
 
217
219
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
218
220
            AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
220
222
            adb_ncDescribeResourceResponseType_reset_correlationId(_ncDescribeResourceResponseType, env);
221
223
            adb_ncDescribeResourceResponseType_reset_userId(_ncDescribeResourceResponseType, env);
222
224
            adb_ncDescribeResourceResponseType_reset_return(_ncDescribeResourceResponseType, env);
 
225
            adb_ncDescribeResourceResponseType_reset_nodeName(_ncDescribeResourceResponseType, env);
223
226
            adb_ncDescribeResourceResponseType_reset_statusMessage(_ncDescribeResourceResponseType, env);
224
227
            adb_ncDescribeResourceResponseType_reset_nodeStatus(_ncDescribeResourceResponseType, env);
225
228
            adb_ncDescribeResourceResponseType_reset_memorySizeMax(_ncDescribeResourceResponseType, env);
229
232
            adb_ncDescribeResourceResponseType_reset_numberOfCoresMax(_ncDescribeResourceResponseType, env);
230
233
            adb_ncDescribeResourceResponseType_reset_numberOfCoresAvailable(_ncDescribeResourceResponseType, env);
231
234
            adb_ncDescribeResourceResponseType_reset_publicSubnets(_ncDescribeResourceResponseType, env);
232
 
 
 
235
            
233
236
 
234
237
            if(_ncDescribeResourceResponseType)
235
238
            {
240
243
        }
241
244
 
242
245
 
243
 
 
 
246
        
244
247
 
245
248
        axis2_status_t AXIS2_CALL
246
249
        adb_ncDescribeResourceResponseType_deserialize(
251
254
                axis2_bool_t dont_care_minoccurs)
252
255
        {
253
256
          axiom_node_t *parent = *dp_parent;
254
 
 
 
257
          
255
258
          axis2_status_t status = AXIS2_SUCCESS;
256
 
 
 
259
           
257
260
             axis2_char_t* text_value = NULL;
258
261
             axutil_qname_t *qname = NULL;
259
 
 
260
 
            axutil_qname_t *element_qname = NULL;
261
 
 
 
262
          
 
263
            axutil_qname_t *element_qname = NULL; 
 
264
            
262
265
               axiom_node_t *first_node = NULL;
263
266
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
264
267
               axiom_node_t *current_node = NULL;
265
268
               axiom_element_t *current_element = NULL;
266
 
 
 
269
            
267
270
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
268
271
            AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
269
272
 
270
 
 
271
 
 
 
273
            
 
274
              
272
275
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
273
276
              {
274
277
                  parent = axiom_node_get_next_sibling(parent, env);
276
279
              if (NULL == parent)
277
280
              {
278
281
                /* This should be checked before everything */
279
 
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
 
282
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
280
283
                            "Failed in building adb object for ncDescribeResourceResponseType : "
281
284
                            "NULL elemenet can not be passed to deserialize");
282
285
                return AXIS2_FAILURE;
283
286
              }
284
 
 
285
 
 
 
287
              
 
288
                      
286
289
                      first_node = axiom_node_get_first_child(parent, env);
287
 
 
288
 
 
289
 
 
290
 
 
 
290
                      
 
291
                    
 
292
 
 
293
                     
291
294
                     /*
292
295
                      * building correlationId element
293
296
                      */
294
 
 
295
 
 
296
 
 
 
297
                     
 
298
                     
 
299
                     
297
300
                                   current_node = first_node;
298
301
                                   is_early_node_valid = AXIS2_FALSE;
299
 
 
300
 
 
 
302
                                   
 
303
                                   
301
304
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
302
305
                                    {
303
306
                                        current_node = axiom_node_get_next_sibling(current_node, env);
307
310
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
308
311
                                        qname = axiom_element_get_qname(current_element, env, current_node);
309
312
                                    }
310
 
 
 
313
                                   
311
314
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
312
 
 
313
 
 
314
 
                           if (
 
315
                                 
 
316
 
 
317
                           if ( 
315
318
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
316
319
                           {
317
320
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
318
321
                              {
319
322
                                is_early_node_valid = AXIS2_TRUE;
320
323
                              }
321
 
 
322
 
 
 
324
                              
 
325
                                 
323
326
                                      text_value = axiom_element_get_text(current_element, env, current_node);
324
327
                                      if(text_value != NULL)
325
328
                                      {
326
329
                                            status = adb_ncDescribeResourceResponseType_set_correlationId(_ncDescribeResourceResponseType, env,
327
330
                                                               text_value);
328
331
                                      }
329
 
 
330
 
                                      else
331
 
                                      {
332
 
                                            /*
333
 
                                             * axis2_qname_t *qname = NULL;
334
 
                                             * axiom_attribute_t *the_attri = NULL;
335
 
                                             *
336
 
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
337
 
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
338
 
                                             */
339
 
                                            /* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
340
 
 
341
 
                                            axiom_attribute_t *the_attri = NULL;
342
 
                                            axis2_char_t *attrib_text = NULL;
343
 
                                            axutil_hash_t *attribute_hash = NULL;
344
 
 
345
 
                                            attribute_hash = axiom_element_get_all_attributes(current_element, env);
346
 
 
347
 
                                            attrib_text = NULL;
348
 
                                            if(attribute_hash)
349
 
                                            {
350
 
                                                 axutil_hash_index_t *hi;
351
 
                                                 void *val;
352
 
                                                 const void *key;
353
 
 
354
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
355
 
                                                 {
356
 
                                                     axutil_hash_this(hi, &key, NULL, &val);
357
 
 
358
 
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
359
 
                                                     {
360
 
                                                         the_attri = (axiom_attribute_t*)val;
361
 
                                                         break;
362
 
                                                     }
363
 
                                                 }
364
 
                                            }
365
 
 
366
 
                                            if(the_attri)
367
 
                                            {
368
 
                                                attrib_text = axiom_attribute_get_value(the_attri, env);
369
 
                                            }
370
 
                                            else
371
 
                                            {
372
 
                                                /* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
373
 
                                                attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
374
 
                                            }
375
 
 
376
 
                                            if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
377
 
                                            {
378
 
                                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
379
 
                                                status = AXIS2_FAILURE;
380
 
                                            }
381
 
                                            else
382
 
                                            {
383
 
                                                /* after all, we found this is a empty string */
384
 
                                                status = adb_ncDescribeResourceResponseType_set_correlationId(_ncDescribeResourceResponseType, env,
385
 
                                                                   "");
386
 
                                            }
387
 
                                      }
388
 
 
 
332
                                      
389
333
                                 if(AXIS2_FAILURE ==  status)
390
334
                                 {
391
335
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
396
340
                                     return AXIS2_FAILURE;
397
341
                                 }
398
342
                              }
399
 
 
 
343
                           
400
344
                  if(element_qname)
401
345
                  {
402
346
                     axutil_qname_free(element_qname, env);
403
347
                     element_qname = NULL;
404
348
                  }
405
 
 
406
 
 
407
 
 
 
349
                 
 
350
 
 
351
                     
408
352
                     /*
409
353
                      * building userId element
410
354
                      */
411
 
 
412
 
 
413
 
 
 
355
                     
 
356
                     
 
357
                     
414
358
                                    /*
415
359
                                     * because elements are ordered this works fine
416
360
                                     */
417
 
 
418
 
 
 
361
                                  
 
362
                                   
419
363
                                   if(current_node != NULL && is_early_node_valid)
420
364
                                   {
421
365
                                       current_node = axiom_node_get_next_sibling(current_node, env);
422
 
 
423
 
 
 
366
                                       
 
367
                                       
424
368
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
425
369
                                        {
426
370
                                            current_node = axiom_node_get_next_sibling(current_node, env);
430
374
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
431
375
                                            qname = axiom_element_get_qname(current_element, env, current_node);
432
376
                                        }
433
 
 
 
377
                                       
434
378
                                   }
435
379
                                   is_early_node_valid = AXIS2_FALSE;
436
 
 
 
380
                                 
437
381
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
438
 
 
439
 
 
440
 
                           if (
 
382
                                 
 
383
 
 
384
                           if ( 
441
385
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
442
386
                           {
443
387
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
444
388
                              {
445
389
                                is_early_node_valid = AXIS2_TRUE;
446
390
                              }
447
 
 
448
 
 
 
391
                              
 
392
                                 
449
393
                                      text_value = axiom_element_get_text(current_element, env, current_node);
450
394
                                      if(text_value != NULL)
451
395
                                      {
452
396
                                            status = adb_ncDescribeResourceResponseType_set_userId(_ncDescribeResourceResponseType, env,
453
397
                                                               text_value);
454
398
                                      }
455
 
 
 
399
                                      
456
400
                                      else
457
401
                                      {
458
402
                                            /*
459
403
                                             * axis2_qname_t *qname = NULL;
460
404
                                             * axiom_attribute_t *the_attri = NULL;
461
 
                                             *
 
405
                                             * 
462
406
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
463
407
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
464
408
                                             */
476
420
                                                 axutil_hash_index_t *hi;
477
421
                                                 void *val;
478
422
                                                 const void *key;
479
 
 
480
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
423
                                        
 
424
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
481
425
                                                 {
482
426
                                                     axutil_hash_this(hi, &key, NULL, &val);
483
 
 
 
427
                                                     
484
428
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
485
429
                                                     {
486
430
                                                         the_attri = (axiom_attribute_t*)val;
511
455
                                                                   "");
512
456
                                            }
513
457
                                      }
514
 
 
 
458
                                      
515
459
                                 if(AXIS2_FAILURE ==  status)
516
460
                                 {
517
461
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
522
466
                                     return AXIS2_FAILURE;
523
467
                                 }
524
468
                              }
525
 
 
 
469
                           
526
470
                  if(element_qname)
527
471
                  {
528
472
                     axutil_qname_free(element_qname, env);
529
473
                     element_qname = NULL;
530
474
                  }
531
 
 
532
 
 
533
 
 
 
475
                 
 
476
 
 
477
                     
534
478
                     /*
535
479
                      * building return element
536
480
                      */
537
 
 
538
 
 
539
 
 
 
481
                     
 
482
                     
 
483
                     
540
484
                                    /*
541
485
                                     * because elements are ordered this works fine
542
486
                                     */
543
 
 
544
 
 
 
487
                                  
 
488
                                   
545
489
                                   if(current_node != NULL && is_early_node_valid)
546
490
                                   {
547
491
                                       current_node = axiom_node_get_next_sibling(current_node, env);
548
 
 
549
 
 
 
492
                                       
 
493
                                       
550
494
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
551
495
                                        {
552
496
                                            current_node = axiom_node_get_next_sibling(current_node, env);
556
500
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
557
501
                                            qname = axiom_element_get_qname(current_element, env, current_node);
558
502
                                        }
559
 
 
 
503
                                       
560
504
                                   }
561
505
                                   is_early_node_valid = AXIS2_FALSE;
562
 
 
 
506
                                 
563
507
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
564
 
 
565
 
 
566
 
                           if (
 
508
                                 
 
509
 
 
510
                           if ( 
567
511
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
568
512
                           {
569
513
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
570
514
                              {
571
515
                                is_early_node_valid = AXIS2_TRUE;
572
516
                              }
573
 
 
574
 
 
 
517
                              
 
518
                                 
575
519
                                      text_value = axiom_element_get_text(current_element, env, current_node);
576
520
                                      if(text_value != NULL)
577
521
                                      {
586
530
                                                                      AXIS2_FALSE);
587
531
                                            }
588
532
                                      }
589
 
 
 
533
                                      
590
534
                                      else
591
535
                                      {
592
536
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
593
537
                                          status = AXIS2_FAILURE;
594
538
                                      }
595
 
 
 
539
                                      
596
540
                                 if(AXIS2_FAILURE ==  status)
597
541
                                 {
598
542
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
603
547
                                     return AXIS2_FAILURE;
604
548
                                 }
605
549
                              }
606
 
 
607
 
                  if(element_qname)
608
 
                  {
609
 
                     axutil_qname_free(element_qname, env);
610
 
                     element_qname = NULL;
611
 
                  }
612
 
 
613
 
 
614
 
 
 
550
                           
 
551
                  if(element_qname)
 
552
                  {
 
553
                     axutil_qname_free(element_qname, env);
 
554
                     element_qname = NULL;
 
555
                  }
 
556
                 
 
557
 
 
558
                     
 
559
                     /*
 
560
                      * building nodeName element
 
561
                      */
 
562
                     
 
563
                     
 
564
                     
 
565
                                    /*
 
566
                                     * because elements are ordered this works fine
 
567
                                     */
 
568
                                  
 
569
                                   
 
570
                                   if(current_node != NULL && is_early_node_valid)
 
571
                                   {
 
572
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
573
                                       
 
574
                                       
 
575
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
576
                                        {
 
577
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
578
                                        }
 
579
                                        if(current_node != NULL)
 
580
                                        {
 
581
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
582
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
583
                                        }
 
584
                                       
 
585
                                   }
 
586
                                   is_early_node_valid = AXIS2_FALSE;
 
587
                                 
 
588
                                 element_qname = axutil_qname_create(env, "nodeName", "http://eucalyptus.ucsb.edu/", NULL);
 
589
                                 
 
590
 
 
591
                           if ( 
 
592
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
593
                           {
 
594
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
595
                              {
 
596
                                is_early_node_valid = AXIS2_TRUE;
 
597
                              }
 
598
                              
 
599
                                 
 
600
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
601
                                      if(text_value != NULL)
 
602
                                      {
 
603
                                            status = adb_ncDescribeResourceResponseType_set_nodeName(_ncDescribeResourceResponseType, env,
 
604
                                                               text_value);
 
605
                                      }
 
606
                                      
 
607
                                 if(AXIS2_FAILURE ==  status)
 
608
                                 {
 
609
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeName ");
 
610
                                     if(element_qname)
 
611
                                     {
 
612
                                         axutil_qname_free(element_qname, env);
 
613
                                     }
 
614
                                     return AXIS2_FAILURE;
 
615
                                 }
 
616
                              }
 
617
                           
 
618
                  if(element_qname)
 
619
                  {
 
620
                     axutil_qname_free(element_qname, env);
 
621
                     element_qname = NULL;
 
622
                  }
 
623
                 
 
624
 
 
625
                     
615
626
                     /*
616
627
                      * building statusMessage element
617
628
                      */
618
 
 
619
 
 
620
 
 
 
629
                     
 
630
                     
 
631
                     
621
632
                                    /*
622
633
                                     * because elements are ordered this works fine
623
634
                                     */
624
 
 
625
 
 
 
635
                                  
 
636
                                   
626
637
                                   if(current_node != NULL && is_early_node_valid)
627
638
                                   {
628
639
                                       current_node = axiom_node_get_next_sibling(current_node, env);
629
 
 
630
 
 
 
640
                                       
 
641
                                       
631
642
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
632
643
                                        {
633
644
                                            current_node = axiom_node_get_next_sibling(current_node, env);
637
648
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
638
649
                                            qname = axiom_element_get_qname(current_element, env, current_node);
639
650
                                        }
640
 
 
 
651
                                       
641
652
                                   }
642
653
                                   is_early_node_valid = AXIS2_FALSE;
643
 
 
 
654
                                 
644
655
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
645
 
 
646
 
 
647
 
                           if (
 
656
                                 
 
657
 
 
658
                           if ( 
648
659
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
649
660
                           {
650
661
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
651
662
                              {
652
663
                                is_early_node_valid = AXIS2_TRUE;
653
664
                              }
654
 
 
655
 
 
 
665
                              
 
666
                                 
656
667
                                      text_value = axiom_element_get_text(current_element, env, current_node);
657
668
                                      if(text_value != NULL)
658
669
                                      {
659
670
                                            status = adb_ncDescribeResourceResponseType_set_statusMessage(_ncDescribeResourceResponseType, env,
660
671
                                                                   atoi(text_value));
661
672
                                      }
662
 
 
 
673
                                      
663
674
                                 if(AXIS2_FAILURE ==  status)
664
675
                                 {
665
676
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
670
681
                                     return AXIS2_FAILURE;
671
682
                                 }
672
683
                              }
673
 
 
 
684
                           
674
685
                  if(element_qname)
675
686
                  {
676
687
                     axutil_qname_free(element_qname, env);
677
688
                     element_qname = NULL;
678
689
                  }
679
 
 
680
 
 
681
 
 
 
690
                 
 
691
 
 
692
                     
682
693
                     /*
683
694
                      * building nodeStatus element
684
695
                      */
685
 
 
686
 
 
687
 
 
 
696
                     
 
697
                     
 
698
                     
688
699
                                    /*
689
700
                                     * because elements are ordered this works fine
690
701
                                     */
691
 
 
692
 
 
 
702
                                  
 
703
                                   
693
704
                                   if(current_node != NULL && is_early_node_valid)
694
705
                                   {
695
706
                                       current_node = axiom_node_get_next_sibling(current_node, env);
696
 
 
697
 
 
 
707
                                       
 
708
                                       
698
709
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
699
710
                                        {
700
711
                                            current_node = axiom_node_get_next_sibling(current_node, env);
704
715
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
705
716
                                            qname = axiom_element_get_qname(current_element, env, current_node);
706
717
                                        }
707
 
 
 
718
                                       
708
719
                                   }
709
720
                                   is_early_node_valid = AXIS2_FALSE;
710
 
 
 
721
                                 
711
722
                                 element_qname = axutil_qname_create(env, "nodeStatus", "http://eucalyptus.ucsb.edu/", NULL);
712
 
 
713
 
 
714
 
                           if (
 
723
                                 
 
724
 
 
725
                           if ( 
715
726
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
716
727
                           {
717
728
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
718
729
                              {
719
730
                                is_early_node_valid = AXIS2_TRUE;
720
731
                              }
721
 
 
722
 
 
 
732
                              
 
733
                                 
723
734
                                      text_value = axiom_element_get_text(current_element, env, current_node);
724
735
                                      if(text_value != NULL)
725
736
                                      {
726
737
                                            status = adb_ncDescribeResourceResponseType_set_nodeStatus(_ncDescribeResourceResponseType, env,
727
738
                                                               text_value);
728
739
                                      }
729
 
 
 
740
                                      
730
741
                                      else
731
742
                                      {
732
743
                                            /*
733
744
                                             * axis2_qname_t *qname = NULL;
734
745
                                             * axiom_attribute_t *the_attri = NULL;
735
 
                                             *
 
746
                                             * 
736
747
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
737
748
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
738
749
                                             */
750
761
                                                 axutil_hash_index_t *hi;
751
762
                                                 void *val;
752
763
                                                 const void *key;
753
 
 
754
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
764
                                        
 
765
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
755
766
                                                 {
756
767
                                                     axutil_hash_this(hi, &key, NULL, &val);
757
 
 
 
768
                                                     
758
769
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
759
770
                                                     {
760
771
                                                         the_attri = (axiom_attribute_t*)val;
785
796
                                                                   "");
786
797
                                            }
787
798
                                      }
788
 
 
 
799
                                      
789
800
                                 if(AXIS2_FAILURE ==  status)
790
801
                                 {
791
802
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for nodeStatus ");
796
807
                                     return AXIS2_FAILURE;
797
808
                                 }
798
809
                              }
799
 
 
 
810
                           
800
811
                              else if(!dont_care_minoccurs)
801
812
                              {
802
813
                                  if(element_qname)
807
818
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element nodeStatus missing");
808
819
                                  return AXIS2_FAILURE;
809
820
                              }
810
 
 
 
821
                           
811
822
                  if(element_qname)
812
823
                  {
813
824
                     axutil_qname_free(element_qname, env);
814
825
                     element_qname = NULL;
815
826
                  }
816
 
 
817
 
 
818
 
 
 
827
                 
 
828
 
 
829
                     
819
830
                     /*
820
831
                      * building memorySizeMax element
821
832
                      */
822
 
 
823
 
 
824
 
 
 
833
                     
 
834
                     
 
835
                     
825
836
                                    /*
826
837
                                     * because elements are ordered this works fine
827
838
                                     */
828
 
 
829
 
 
 
839
                                  
 
840
                                   
830
841
                                   if(current_node != NULL && is_early_node_valid)
831
842
                                   {
832
843
                                       current_node = axiom_node_get_next_sibling(current_node, env);
833
 
 
834
 
 
 
844
                                       
 
845
                                       
835
846
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
836
847
                                        {
837
848
                                            current_node = axiom_node_get_next_sibling(current_node, env);
841
852
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
842
853
                                            qname = axiom_element_get_qname(current_element, env, current_node);
843
854
                                        }
844
 
 
 
855
                                       
845
856
                                   }
846
857
                                   is_early_node_valid = AXIS2_FALSE;
847
 
 
 
858
                                 
848
859
                                 element_qname = axutil_qname_create(env, "memorySizeMax", "http://eucalyptus.ucsb.edu/", NULL);
849
 
 
850
 
 
851
 
                           if (
 
860
                                 
 
861
 
 
862
                           if ( 
852
863
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
853
864
                           {
854
865
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
855
866
                              {
856
867
                                is_early_node_valid = AXIS2_TRUE;
857
868
                              }
858
 
 
859
 
 
 
869
                              
 
870
                                 
860
871
                                      text_value = axiom_element_get_text(current_element, env, current_node);
861
872
                                      if(text_value != NULL)
862
873
                                      {
863
874
                                            status = adb_ncDescribeResourceResponseType_set_memorySizeMax(_ncDescribeResourceResponseType, env,
864
875
                                                                   atoi(text_value));
865
876
                                      }
866
 
 
 
877
                                      
867
878
                                      else
868
879
                                      {
869
880
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element memorySizeMax");
870
881
                                          status = AXIS2_FAILURE;
871
882
                                      }
872
 
 
 
883
                                      
873
884
                                 if(AXIS2_FAILURE ==  status)
874
885
                                 {
875
886
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for memorySizeMax ");
880
891
                                     return AXIS2_FAILURE;
881
892
                                 }
882
893
                              }
883
 
 
 
894
                           
884
895
                              else if(!dont_care_minoccurs)
885
896
                              {
886
897
                                  if(element_qname)
891
902
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element memorySizeMax missing");
892
903
                                  return AXIS2_FAILURE;
893
904
                              }
894
 
 
 
905
                           
895
906
                  if(element_qname)
896
907
                  {
897
908
                     axutil_qname_free(element_qname, env);
898
909
                     element_qname = NULL;
899
910
                  }
900
 
 
901
 
 
902
 
 
 
911
                 
 
912
 
 
913
                     
903
914
                     /*
904
915
                      * building memorySizeAvailable element
905
916
                      */
906
 
 
907
 
 
908
 
 
 
917
                     
 
918
                     
 
919
                     
909
920
                                    /*
910
921
                                     * because elements are ordered this works fine
911
922
                                     */
912
 
 
913
 
 
 
923
                                  
 
924
                                   
914
925
                                   if(current_node != NULL && is_early_node_valid)
915
926
                                   {
916
927
                                       current_node = axiom_node_get_next_sibling(current_node, env);
917
 
 
918
 
 
 
928
                                       
 
929
                                       
919
930
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
920
931
                                        {
921
932
                                            current_node = axiom_node_get_next_sibling(current_node, env);
925
936
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
926
937
                                            qname = axiom_element_get_qname(current_element, env, current_node);
927
938
                                        }
928
 
 
 
939
                                       
929
940
                                   }
930
941
                                   is_early_node_valid = AXIS2_FALSE;
931
 
 
 
942
                                 
932
943
                                 element_qname = axutil_qname_create(env, "memorySizeAvailable", "http://eucalyptus.ucsb.edu/", NULL);
933
 
 
934
 
 
935
 
                           if (
 
944
                                 
 
945
 
 
946
                           if ( 
936
947
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
937
948
                           {
938
949
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
939
950
                              {
940
951
                                is_early_node_valid = AXIS2_TRUE;
941
952
                              }
942
 
 
943
 
 
 
953
                              
 
954
                                 
944
955
                                      text_value = axiom_element_get_text(current_element, env, current_node);
945
956
                                      if(text_value != NULL)
946
957
                                      {
947
958
                                            status = adb_ncDescribeResourceResponseType_set_memorySizeAvailable(_ncDescribeResourceResponseType, env,
948
959
                                                                   atoi(text_value));
949
960
                                      }
950
 
 
 
961
                                      
951
962
                                      else
952
963
                                      {
953
964
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element memorySizeAvailable");
954
965
                                          status = AXIS2_FAILURE;
955
966
                                      }
956
 
 
 
967
                                      
957
968
                                 if(AXIS2_FAILURE ==  status)
958
969
                                 {
959
970
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for memorySizeAvailable ");
964
975
                                     return AXIS2_FAILURE;
965
976
                                 }
966
977
                              }
967
 
 
 
978
                           
968
979
                              else if(!dont_care_minoccurs)
969
980
                              {
970
981
                                  if(element_qname)
975
986
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element memorySizeAvailable missing");
976
987
                                  return AXIS2_FAILURE;
977
988
                              }
978
 
 
 
989
                           
979
990
                  if(element_qname)
980
991
                  {
981
992
                     axutil_qname_free(element_qname, env);
982
993
                     element_qname = NULL;
983
994
                  }
984
 
 
985
 
 
986
 
 
 
995
                 
 
996
 
 
997
                     
987
998
                     /*
988
999
                      * building diskSizeMax element
989
1000
                      */
990
 
 
991
 
 
992
 
 
 
1001
                     
 
1002
                     
 
1003
                     
993
1004
                                    /*
994
1005
                                     * because elements are ordered this works fine
995
1006
                                     */
996
 
 
997
 
 
 
1007
                                  
 
1008
                                   
998
1009
                                   if(current_node != NULL && is_early_node_valid)
999
1010
                                   {
1000
1011
                                       current_node = axiom_node_get_next_sibling(current_node, env);
1001
 
 
1002
 
 
 
1012
                                       
 
1013
                                       
1003
1014
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1004
1015
                                        {
1005
1016
                                            current_node = axiom_node_get_next_sibling(current_node, env);
1009
1020
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1010
1021
                                            qname = axiom_element_get_qname(current_element, env, current_node);
1011
1022
                                        }
1012
 
 
 
1023
                                       
1013
1024
                                   }
1014
1025
                                   is_early_node_valid = AXIS2_FALSE;
1015
 
 
 
1026
                                 
1016
1027
                                 element_qname = axutil_qname_create(env, "diskSizeMax", "http://eucalyptus.ucsb.edu/", NULL);
1017
 
 
1018
 
 
1019
 
                           if (
 
1028
                                 
 
1029
 
 
1030
                           if ( 
1020
1031
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
1021
1032
                           {
1022
1033
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
1023
1034
                              {
1024
1035
                                is_early_node_valid = AXIS2_TRUE;
1025
1036
                              }
1026
 
 
1027
 
 
 
1037
                              
 
1038
                                 
1028
1039
                                      text_value = axiom_element_get_text(current_element, env, current_node);
1029
1040
                                      if(text_value != NULL)
1030
1041
                                      {
1031
1042
                                            status = adb_ncDescribeResourceResponseType_set_diskSizeMax(_ncDescribeResourceResponseType, env,
1032
1043
                                                                   atoi(text_value));
1033
1044
                                      }
1034
 
 
 
1045
                                      
1035
1046
                                      else
1036
1047
                                      {
1037
1048
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element diskSizeMax");
1038
1049
                                          status = AXIS2_FAILURE;
1039
1050
                                      }
1040
 
 
 
1051
                                      
1041
1052
                                 if(AXIS2_FAILURE ==  status)
1042
1053
                                 {
1043
1054
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for diskSizeMax ");
1048
1059
                                     return AXIS2_FAILURE;
1049
1060
                                 }
1050
1061
                              }
1051
 
 
 
1062
                           
1052
1063
                              else if(!dont_care_minoccurs)
1053
1064
                              {
1054
1065
                                  if(element_qname)
1059
1070
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element diskSizeMax missing");
1060
1071
                                  return AXIS2_FAILURE;
1061
1072
                              }
1062
 
 
 
1073
                           
1063
1074
                  if(element_qname)
1064
1075
                  {
1065
1076
                     axutil_qname_free(element_qname, env);
1066
1077
                     element_qname = NULL;
1067
1078
                  }
1068
 
 
1069
 
 
1070
 
 
 
1079
                 
 
1080
 
 
1081
                     
1071
1082
                     /*
1072
1083
                      * building diskSizeAvailable element
1073
1084
                      */
1074
 
 
1075
 
 
1076
 
 
 
1085
                     
 
1086
                     
 
1087
                     
1077
1088
                                    /*
1078
1089
                                     * because elements are ordered this works fine
1079
1090
                                     */
1080
 
 
1081
 
 
 
1091
                                  
 
1092
                                   
1082
1093
                                   if(current_node != NULL && is_early_node_valid)
1083
1094
                                   {
1084
1095
                                       current_node = axiom_node_get_next_sibling(current_node, env);
1085
 
 
1086
 
 
 
1096
                                       
 
1097
                                       
1087
1098
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1088
1099
                                        {
1089
1100
                                            current_node = axiom_node_get_next_sibling(current_node, env);
1093
1104
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1094
1105
                                            qname = axiom_element_get_qname(current_element, env, current_node);
1095
1106
                                        }
1096
 
 
 
1107
                                       
1097
1108
                                   }
1098
1109
                                   is_early_node_valid = AXIS2_FALSE;
1099
 
 
 
1110
                                 
1100
1111
                                 element_qname = axutil_qname_create(env, "diskSizeAvailable", "http://eucalyptus.ucsb.edu/", NULL);
1101
 
 
1102
 
 
1103
 
                           if (
 
1112
                                 
 
1113
 
 
1114
                           if ( 
1104
1115
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
1105
1116
                           {
1106
1117
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
1107
1118
                              {
1108
1119
                                is_early_node_valid = AXIS2_TRUE;
1109
1120
                              }
1110
 
 
1111
 
 
 
1121
                              
 
1122
                                 
1112
1123
                                      text_value = axiom_element_get_text(current_element, env, current_node);
1113
1124
                                      if(text_value != NULL)
1114
1125
                                      {
1115
1126
                                            status = adb_ncDescribeResourceResponseType_set_diskSizeAvailable(_ncDescribeResourceResponseType, env,
1116
1127
                                                                   atoi(text_value));
1117
1128
                                      }
1118
 
 
 
1129
                                      
1119
1130
                                      else
1120
1131
                                      {
1121
1132
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element diskSizeAvailable");
1122
1133
                                          status = AXIS2_FAILURE;
1123
1134
                                      }
1124
 
 
 
1135
                                      
1125
1136
                                 if(AXIS2_FAILURE ==  status)
1126
1137
                                 {
1127
1138
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for diskSizeAvailable ");
1132
1143
                                     return AXIS2_FAILURE;
1133
1144
                                 }
1134
1145
                              }
1135
 
 
 
1146
                           
1136
1147
                              else if(!dont_care_minoccurs)
1137
1148
                              {
1138
1149
                                  if(element_qname)
1143
1154
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element diskSizeAvailable missing");
1144
1155
                                  return AXIS2_FAILURE;
1145
1156
                              }
1146
 
 
 
1157
                           
1147
1158
                  if(element_qname)
1148
1159
                  {
1149
1160
                     axutil_qname_free(element_qname, env);
1150
1161
                     element_qname = NULL;
1151
1162
                  }
1152
 
 
1153
 
 
1154
 
 
 
1163
                 
 
1164
 
 
1165
                     
1155
1166
                     /*
1156
1167
                      * building numberOfCoresMax element
1157
1168
                      */
1158
 
 
1159
 
 
1160
 
 
 
1169
                     
 
1170
                     
 
1171
                     
1161
1172
                                    /*
1162
1173
                                     * because elements are ordered this works fine
1163
1174
                                     */
1164
 
 
1165
 
 
 
1175
                                  
 
1176
                                   
1166
1177
                                   if(current_node != NULL && is_early_node_valid)
1167
1178
                                   {
1168
1179
                                       current_node = axiom_node_get_next_sibling(current_node, env);
1169
 
 
1170
 
 
 
1180
                                       
 
1181
                                       
1171
1182
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1172
1183
                                        {
1173
1184
                                            current_node = axiom_node_get_next_sibling(current_node, env);
1177
1188
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1178
1189
                                            qname = axiom_element_get_qname(current_element, env, current_node);
1179
1190
                                        }
1180
 
 
 
1191
                                       
1181
1192
                                   }
1182
1193
                                   is_early_node_valid = AXIS2_FALSE;
1183
 
 
 
1194
                                 
1184
1195
                                 element_qname = axutil_qname_create(env, "numberOfCoresMax", "http://eucalyptus.ucsb.edu/", NULL);
1185
 
 
1186
 
 
1187
 
                           if (
 
1196
                                 
 
1197
 
 
1198
                           if ( 
1188
1199
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
1189
1200
                           {
1190
1201
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
1191
1202
                              {
1192
1203
                                is_early_node_valid = AXIS2_TRUE;
1193
1204
                              }
1194
 
 
1195
 
 
 
1205
                              
 
1206
                                 
1196
1207
                                      text_value = axiom_element_get_text(current_element, env, current_node);
1197
1208
                                      if(text_value != NULL)
1198
1209
                                      {
1199
1210
                                            status = adb_ncDescribeResourceResponseType_set_numberOfCoresMax(_ncDescribeResourceResponseType, env,
1200
1211
                                                                   atoi(text_value));
1201
1212
                                      }
1202
 
 
 
1213
                                      
1203
1214
                                      else
1204
1215
                                      {
1205
1216
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element numberOfCoresMax");
1206
1217
                                          status = AXIS2_FAILURE;
1207
1218
                                      }
1208
 
 
 
1219
                                      
1209
1220
                                 if(AXIS2_FAILURE ==  status)
1210
1221
                                 {
1211
1222
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for numberOfCoresMax ");
1216
1227
                                     return AXIS2_FAILURE;
1217
1228
                                 }
1218
1229
                              }
1219
 
 
 
1230
                           
1220
1231
                              else if(!dont_care_minoccurs)
1221
1232
                              {
1222
1233
                                  if(element_qname)
1227
1238
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element numberOfCoresMax missing");
1228
1239
                                  return AXIS2_FAILURE;
1229
1240
                              }
1230
 
 
 
1241
                           
1231
1242
                  if(element_qname)
1232
1243
                  {
1233
1244
                     axutil_qname_free(element_qname, env);
1234
1245
                     element_qname = NULL;
1235
1246
                  }
1236
 
 
1237
 
 
1238
 
 
 
1247
                 
 
1248
 
 
1249
                     
1239
1250
                     /*
1240
1251
                      * building numberOfCoresAvailable element
1241
1252
                      */
1242
 
 
1243
 
 
1244
 
 
 
1253
                     
 
1254
                     
 
1255
                     
1245
1256
                                    /*
1246
1257
                                     * because elements are ordered this works fine
1247
1258
                                     */
1248
 
 
1249
 
 
 
1259
                                  
 
1260
                                   
1250
1261
                                   if(current_node != NULL && is_early_node_valid)
1251
1262
                                   {
1252
1263
                                       current_node = axiom_node_get_next_sibling(current_node, env);
1253
 
 
1254
 
 
 
1264
                                       
 
1265
                                       
1255
1266
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1256
1267
                                        {
1257
1268
                                            current_node = axiom_node_get_next_sibling(current_node, env);
1261
1272
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1262
1273
                                            qname = axiom_element_get_qname(current_element, env, current_node);
1263
1274
                                        }
1264
 
 
 
1275
                                       
1265
1276
                                   }
1266
1277
                                   is_early_node_valid = AXIS2_FALSE;
1267
 
 
 
1278
                                 
1268
1279
                                 element_qname = axutil_qname_create(env, "numberOfCoresAvailable", "http://eucalyptus.ucsb.edu/", NULL);
1269
 
 
1270
 
 
1271
 
                           if (
 
1280
                                 
 
1281
 
 
1282
                           if ( 
1272
1283
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
1273
1284
                           {
1274
1285
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
1275
1286
                              {
1276
1287
                                is_early_node_valid = AXIS2_TRUE;
1277
1288
                              }
1278
 
 
1279
 
 
 
1289
                              
 
1290
                                 
1280
1291
                                      text_value = axiom_element_get_text(current_element, env, current_node);
1281
1292
                                      if(text_value != NULL)
1282
1293
                                      {
1283
1294
                                            status = adb_ncDescribeResourceResponseType_set_numberOfCoresAvailable(_ncDescribeResourceResponseType, env,
1284
1295
                                                                   atoi(text_value));
1285
1296
                                      }
1286
 
 
 
1297
                                      
1287
1298
                                      else
1288
1299
                                      {
1289
1300
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element numberOfCoresAvailable");
1290
1301
                                          status = AXIS2_FAILURE;
1291
1302
                                      }
1292
 
 
 
1303
                                      
1293
1304
                                 if(AXIS2_FAILURE ==  status)
1294
1305
                                 {
1295
1306
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for numberOfCoresAvailable ");
1300
1311
                                     return AXIS2_FAILURE;
1301
1312
                                 }
1302
1313
                              }
1303
 
 
 
1314
                           
1304
1315
                              else if(!dont_care_minoccurs)
1305
1316
                              {
1306
1317
                                  if(element_qname)
1311
1322
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element numberOfCoresAvailable missing");
1312
1323
                                  return AXIS2_FAILURE;
1313
1324
                              }
1314
 
 
 
1325
                           
1315
1326
                  if(element_qname)
1316
1327
                  {
1317
1328
                     axutil_qname_free(element_qname, env);
1318
1329
                     element_qname = NULL;
1319
1330
                  }
1320
 
 
1321
 
 
1322
 
 
 
1331
                 
 
1332
 
 
1333
                     
1323
1334
                     /*
1324
1335
                      * building publicSubnets element
1325
1336
                      */
1326
 
 
1327
 
 
1328
 
 
 
1337
                     
 
1338
                     
 
1339
                     
1329
1340
                                    /*
1330
1341
                                     * because elements are ordered this works fine
1331
1342
                                     */
1332
 
 
1333
 
 
 
1343
                                  
 
1344
                                   
1334
1345
                                   if(current_node != NULL && is_early_node_valid)
1335
1346
                                   {
1336
1347
                                       current_node = axiom_node_get_next_sibling(current_node, env);
1337
 
 
1338
 
 
 
1348
                                       
 
1349
                                       
1339
1350
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1340
1351
                                        {
1341
1352
                                            current_node = axiom_node_get_next_sibling(current_node, env);
1345
1356
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1346
1357
                                            qname = axiom_element_get_qname(current_element, env, current_node);
1347
1358
                                        }
1348
 
 
 
1359
                                       
1349
1360
                                   }
1350
1361
                                   is_early_node_valid = AXIS2_FALSE;
1351
 
 
 
1362
                                 
1352
1363
                                 element_qname = axutil_qname_create(env, "publicSubnets", "http://eucalyptus.ucsb.edu/", NULL);
1353
 
 
1354
 
 
1355
 
                           if (
 
1364
                                 
 
1365
 
 
1366
                           if ( 
1356
1367
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
1357
1368
                           {
1358
1369
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
1359
1370
                              {
1360
1371
                                is_early_node_valid = AXIS2_TRUE;
1361
1372
                              }
1362
 
 
1363
 
 
 
1373
                              
 
1374
                                 
1364
1375
                                      text_value = axiom_element_get_text(current_element, env, current_node);
1365
1376
                                      if(text_value != NULL)
1366
1377
                                      {
1367
1378
                                            status = adb_ncDescribeResourceResponseType_set_publicSubnets(_ncDescribeResourceResponseType, env,
1368
1379
                                                               text_value);
1369
1380
                                      }
1370
 
 
 
1381
                                      
1371
1382
                                      else
1372
1383
                                      {
1373
1384
                                            /*
1374
1385
                                             * axis2_qname_t *qname = NULL;
1375
1386
                                             * axiom_attribute_t *the_attri = NULL;
1376
 
                                             *
 
1387
                                             * 
1377
1388
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1378
1389
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
1379
1390
                                             */
1391
1402
                                                 axutil_hash_index_t *hi;
1392
1403
                                                 void *val;
1393
1404
                                                 const void *key;
1394
 
 
1395
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
1405
                                        
 
1406
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
1396
1407
                                                 {
1397
1408
                                                     axutil_hash_this(hi, &key, NULL, &val);
1398
 
 
 
1409
                                                     
1399
1410
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1400
1411
                                                     {
1401
1412
                                                         the_attri = (axiom_attribute_t*)val;
1426
1437
                                                                   "");
1427
1438
                                            }
1428
1439
                                      }
1429
 
 
 
1440
                                      
1430
1441
                                 if(AXIS2_FAILURE ==  status)
1431
1442
                                 {
1432
1443
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for publicSubnets ");
1437
1448
                                     return AXIS2_FAILURE;
1438
1449
                                 }
1439
1450
                              }
1440
 
 
 
1451
                           
1441
1452
                              else if(!dont_care_minoccurs)
1442
1453
                              {
1443
1454
                                  if(element_qname)
1448
1459
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element publicSubnets missing");
1449
1460
                                  return AXIS2_FAILURE;
1450
1461
                              }
1451
 
 
 
1462
                           
1452
1463
                  if(element_qname)
1453
1464
                  {
1454
1465
                     axutil_qname_free(element_qname, env);
1455
1466
                     element_qname = NULL;
1456
1467
                  }
1457
 
 
 
1468
                 
1458
1469
          return status;
1459
1470
       }
1460
1471
 
1461
1472
          axis2_bool_t AXIS2_CALL
1462
1473
          adb_ncDescribeResourceResponseType_is_particle()
1463
1474
          {
1464
 
 
 
1475
            
1465
1476
                 return AXIS2_FALSE;
1466
 
 
 
1477
              
1467
1478
          }
1468
1479
 
1469
1480
 
1473
1484
                    const axutil_env_t *env, axiom_element_t *parent_element,
1474
1485
                    axutil_hash_t *namespaces, int *next_ns_index)
1475
1486
          {
1476
 
 
 
1487
            
1477
1488
                  /* Here this is an empty function, Nothing to declare */
1478
 
 
 
1489
                 
1479
1490
          }
1480
1491
 
1481
 
 
1482
 
 
 
1492
        
 
1493
        
1483
1494
        axiom_node_t* AXIS2_CALL
1484
1495
        adb_ncDescribeResourceResponseType_serialize(
1485
1496
                adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
1486
1497
                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)
1487
1498
        {
1488
 
 
1489
 
 
 
1499
            
 
1500
            
1490
1501
             axis2_char_t *string_to_stream;
1491
 
 
1492
 
 
 
1502
            
 
1503
         
1493
1504
         axiom_node_t *current_node = NULL;
1494
1505
         int tag_closed = 0;
1495
1506
 
1496
 
 
1497
 
 
 
1507
         
 
1508
         
1498
1509
                axiom_namespace_t *ns1 = NULL;
1499
1510
 
1500
1511
                axis2_char_t *qname_uri = NULL;
1501
1512
                axis2_char_t *qname_prefix = NULL;
1502
1513
                axis2_char_t *p_prefix = NULL;
1503
1514
                axis2_bool_t ns_already_defined;
1504
 
 
 
1515
            
1505
1516
                    axis2_char_t *text_value_1;
1506
1517
                    axis2_char_t *text_value_1_temp;
1507
 
 
 
1518
                    
1508
1519
                    axis2_char_t *text_value_2;
1509
1520
                    axis2_char_t *text_value_2_temp;
1510
 
 
 
1521
                    
1511
1522
                    axis2_char_t text_value_3[64];
1512
 
 
1513
 
                    axis2_char_t text_value_4[64];
1514
 
 
1515
 
                    axis2_char_t *text_value_5;
1516
 
                    axis2_char_t *text_value_5_temp;
1517
 
 
1518
 
                    axis2_char_t text_value_6[64];
1519
 
 
 
1523
                    
 
1524
                    axis2_char_t *text_value_4;
 
1525
                    axis2_char_t *text_value_4_temp;
 
1526
                    
 
1527
                    axis2_char_t text_value_5[64];
 
1528
                    
 
1529
                    axis2_char_t *text_value_6;
 
1530
                    axis2_char_t *text_value_6_temp;
 
1531
                    
1520
1532
                    axis2_char_t text_value_7[64];
1521
 
 
 
1533
                    
1522
1534
                    axis2_char_t text_value_8[64];
1523
 
 
 
1535
                    
1524
1536
                    axis2_char_t text_value_9[64];
1525
 
 
 
1537
                    
1526
1538
                    axis2_char_t text_value_10[64];
1527
 
 
 
1539
                    
1528
1540
                    axis2_char_t text_value_11[64];
1529
 
 
1530
 
                    axis2_char_t *text_value_12;
1531
 
                    axis2_char_t *text_value_12_temp;
1532
 
 
 
1541
                    
 
1542
                    axis2_char_t text_value_12[64];
 
1543
                    
 
1544
                    axis2_char_t *text_value_13;
 
1545
                    axis2_char_t *text_value_13_temp;
 
1546
                    
1533
1547
               axis2_char_t *start_input_str = NULL;
1534
1548
               axis2_char_t *end_input_str = NULL;
1535
1549
               unsigned int start_input_str_len = 0;
1536
1550
               unsigned int end_input_str_len = 0;
1537
 
 
1538
 
 
 
1551
            
 
1552
            
1539
1553
               axiom_data_source_t *data_source = NULL;
1540
1554
               axutil_stream_t *stream = NULL;
1541
1555
 
1542
 
 
 
1556
            
1543
1557
 
1544
1558
            AXIS2_ENV_CHECK(env, NULL);
1545
1559
            AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
1546
 
 
1547
 
 
 
1560
            
 
1561
            
1548
1562
                    current_node = parent;
1549
1563
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1550
1564
                    if (!data_source)
1552
1566
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1553
1567
                    if (!stream)
1554
1568
                        return NULL;
1555
 
 
 
1569
                  
1556
1570
            if(!parent_tag_closed)
1557
1571
            {
1558
 
 
1559
 
              string_to_stream = ">";
 
1572
            
 
1573
              string_to_stream = ">"; 
1560
1574
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1561
1575
              tag_closed = 1;
1562
 
 
 
1576
            
1563
1577
            }
1564
 
 
 
1578
            
1565
1579
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1566
1580
                       {
1567
1581
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1568
1582
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1569
1583
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1570
 
 
 
1584
                           
1571
1585
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1572
1586
                                            "http://eucalyptus.ucsb.edu/",
1573
1587
                                            p_prefix));
1574
1588
                       }
1575
 
 
 
1589
                      
1576
1590
 
1577
1591
                   if (!_ncDescribeResourceResponseType->is_valid_correlationId)
1578
1592
                   {
1579
 
 
 
1593
                      
1580
1594
                           /* no need to complain for minoccurs=0 element */
1581
 
 
1582
 
 
 
1595
                            
 
1596
                          
1583
1597
                   }
1584
1598
                   else
1585
1599
                   {
1586
1600
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1587
 
                                 (4 + axutil_strlen(p_prefix) +
1588
 
                                  axutil_strlen("correlationId")));
1589
 
 
 
1601
                                 (4 + axutil_strlen(p_prefix) + 
 
1602
                                  axutil_strlen("correlationId"))); 
 
1603
                                 
1590
1604
                                 /* axutil_strlen("<:>") + 1 = 4 */
1591
1605
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1592
1606
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1593
1607
                                  /* axutil_strlen("</:>") + 1 = 5 */
1594
 
 
1595
 
 
1596
 
 
1597
 
 
1598
 
 
1599
 
 
 
1608
                                  
 
1609
                     
 
1610
 
 
1611
                   
 
1612
                   
 
1613
                     
1600
1614
                     /*
1601
1615
                      * parsing correlationId element
1602
1616
                      */
1603
1617
 
1604
 
 
1605
 
 
 
1618
                    
 
1619
                    
1606
1620
                            sprintf(start_input_str, "<%s%scorrelationId>",
1607
1621
                                 p_prefix?p_prefix:"",
1608
1622
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1609
 
 
 
1623
                            
1610
1624
                        start_input_str_len = axutil_strlen(start_input_str);
1611
1625
                        sprintf(end_input_str, "</%s%scorrelationId>",
1612
1626
                                 p_prefix?p_prefix:"",
1613
1627
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1614
1628
                        end_input_str_len = axutil_strlen(end_input_str);
1615
 
 
 
1629
                    
1616
1630
                           text_value_1 = _ncDescribeResourceResponseType->property_correlationId;
1617
 
 
 
1631
                           
1618
1632
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1619
 
 
1620
 
 
 
1633
                           
 
1634
                            
1621
1635
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1622
1636
                           if (text_value_1_temp)
1623
1637
                           {
1628
1642
                           {
1629
1643
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1630
1644
                           }
1631
 
 
 
1645
                           
1632
1646
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1633
 
 
1634
 
 
 
1647
                           
 
1648
                     
1635
1649
                     AXIS2_FREE(env->allocator,start_input_str);
1636
1650
                     AXIS2_FREE(env->allocator,end_input_str);
1637
 
                 }
1638
 
 
1639
 
 
 
1651
                 } 
 
1652
 
 
1653
                 
1640
1654
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1641
1655
                       {
1642
1656
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1643
1657
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1644
1658
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1645
 
 
 
1659
                           
1646
1660
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1647
1661
                                            "http://eucalyptus.ucsb.edu/",
1648
1662
                                            p_prefix));
1649
1663
                       }
1650
 
 
 
1664
                      
1651
1665
 
1652
1666
                   if (!_ncDescribeResourceResponseType->is_valid_userId)
1653
1667
                   {
1654
 
 
 
1668
                      
1655
1669
                           /* no need to complain for minoccurs=0 element */
1656
 
 
1657
 
 
 
1670
                            
 
1671
                          
1658
1672
                   }
1659
1673
                   else
1660
1674
                   {
1661
1675
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1662
 
                                 (4 + axutil_strlen(p_prefix) +
1663
 
                                  axutil_strlen("userId")));
1664
 
 
 
1676
                                 (4 + axutil_strlen(p_prefix) + 
 
1677
                                  axutil_strlen("userId"))); 
 
1678
                                 
1665
1679
                                 /* axutil_strlen("<:>") + 1 = 4 */
1666
1680
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1667
1681
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1668
1682
                                  /* axutil_strlen("</:>") + 1 = 5 */
1669
 
 
1670
 
 
1671
 
 
1672
 
 
1673
 
 
1674
 
 
 
1683
                                  
 
1684
                     
 
1685
 
 
1686
                   
 
1687
                   
 
1688
                     
1675
1689
                     /*
1676
1690
                      * parsing userId element
1677
1691
                      */
1678
1692
 
1679
 
 
1680
 
 
 
1693
                    
 
1694
                    
1681
1695
                            sprintf(start_input_str, "<%s%suserId>",
1682
1696
                                 p_prefix?p_prefix:"",
1683
1697
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1684
 
 
 
1698
                            
1685
1699
                        start_input_str_len = axutil_strlen(start_input_str);
1686
1700
                        sprintf(end_input_str, "</%s%suserId>",
1687
1701
                                 p_prefix?p_prefix:"",
1688
1702
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1689
1703
                        end_input_str_len = axutil_strlen(end_input_str);
1690
 
 
 
1704
                    
1691
1705
                           text_value_2 = _ncDescribeResourceResponseType->property_userId;
1692
 
 
 
1706
                           
1693
1707
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1694
 
 
1695
 
 
 
1708
                           
 
1709
                            
1696
1710
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1697
1711
                           if (text_value_2_temp)
1698
1712
                           {
1703
1717
                           {
1704
1718
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1705
1719
                           }
1706
 
 
 
1720
                           
1707
1721
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1708
 
 
1709
 
 
 
1722
                           
 
1723
                     
1710
1724
                     AXIS2_FREE(env->allocator,start_input_str);
1711
1725
                     AXIS2_FREE(env->allocator,end_input_str);
1712
 
                 }
1713
 
 
1714
 
 
 
1726
                 } 
 
1727
 
 
1728
                 
1715
1729
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1716
1730
                       {
1717
1731
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1718
1732
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1719
1733
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1720
 
 
 
1734
                           
1721
1735
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1722
1736
                                            "http://eucalyptus.ucsb.edu/",
1723
1737
                                            p_prefix));
1724
1738
                       }
1725
 
 
 
1739
                      
1726
1740
 
1727
1741
                   if (!_ncDescribeResourceResponseType->is_valid_return)
1728
1742
                   {
1729
 
 
 
1743
                      
1730
1744
                           /* no need to complain for minoccurs=0 element */
1731
 
 
1732
 
 
 
1745
                            
 
1746
                          
1733
1747
                   }
1734
1748
                   else
1735
1749
                   {
1736
1750
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1737
 
                                 (4 + axutil_strlen(p_prefix) +
1738
 
                                  axutil_strlen("return")));
1739
 
 
 
1751
                                 (4 + axutil_strlen(p_prefix) + 
 
1752
                                  axutil_strlen("return"))); 
 
1753
                                 
1740
1754
                                 /* axutil_strlen("<:>") + 1 = 4 */
1741
1755
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1742
1756
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1743
1757
                                  /* axutil_strlen("</:>") + 1 = 5 */
1744
 
 
1745
 
 
1746
 
 
1747
 
 
1748
 
 
1749
 
 
 
1758
                                  
 
1759
                     
 
1760
 
 
1761
                   
 
1762
                   
 
1763
                     
1750
1764
                     /*
1751
1765
                      * parsing return element
1752
1766
                      */
1753
1767
 
1754
 
 
1755
 
 
 
1768
                    
 
1769
                    
1756
1770
                            sprintf(start_input_str, "<%s%sreturn>",
1757
1771
                                 p_prefix?p_prefix:"",
1758
1772
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1759
 
 
 
1773
                            
1760
1774
                        start_input_str_len = axutil_strlen(start_input_str);
1761
1775
                        sprintf(end_input_str, "</%s%sreturn>",
1762
1776
                                 p_prefix?p_prefix:"",
1763
1777
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1764
1778
                        end_input_str_len = axutil_strlen(end_input_str);
1765
 
 
 
1779
                    
1766
1780
                           strcpy(text_value_3, (_ncDescribeResourceResponseType->property_return)?"true":"false");
1767
 
 
 
1781
                           
1768
1782
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1769
 
 
 
1783
                           
1770
1784
                           axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1771
 
 
1772
 
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1773
 
 
1774
 
 
1775
 
                     AXIS2_FREE(env->allocator,start_input_str);
1776
 
                     AXIS2_FREE(env->allocator,end_input_str);
1777
 
                 }
1778
 
 
1779
 
 
1780
 
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1781
 
                       {
1782
 
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1783
 
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1784
 
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1785
 
 
1786
 
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1787
 
                                            "http://eucalyptus.ucsb.edu/",
1788
 
                                            p_prefix));
1789
 
                       }
1790
 
 
 
1785
                           
 
1786
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
1787
                           
 
1788
                     
 
1789
                     AXIS2_FREE(env->allocator,start_input_str);
 
1790
                     AXIS2_FREE(env->allocator,end_input_str);
 
1791
                 } 
 
1792
 
 
1793
                 
 
1794
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
1795
                       {
 
1796
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
1797
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
1798
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
1799
                           
 
1800
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
1801
                                            "http://eucalyptus.ucsb.edu/",
 
1802
                                            p_prefix));
 
1803
                       }
 
1804
                      
 
1805
 
 
1806
                   if (!_ncDescribeResourceResponseType->is_valid_nodeName)
 
1807
                   {
 
1808
                      
 
1809
                           /* no need to complain for minoccurs=0 element */
 
1810
                            
 
1811
                          
 
1812
                   }
 
1813
                   else
 
1814
                   {
 
1815
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1816
                                 (4 + axutil_strlen(p_prefix) + 
 
1817
                                  axutil_strlen("nodeName"))); 
 
1818
                                 
 
1819
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
1820
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
1821
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("nodeName")));
 
1822
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
1823
                                  
 
1824
                     
 
1825
 
 
1826
                   
 
1827
                   
 
1828
                     
 
1829
                     /*
 
1830
                      * parsing nodeName element
 
1831
                      */
 
1832
 
 
1833
                    
 
1834
                    
 
1835
                            sprintf(start_input_str, "<%s%snodeName>",
 
1836
                                 p_prefix?p_prefix:"",
 
1837
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1838
                            
 
1839
                        start_input_str_len = axutil_strlen(start_input_str);
 
1840
                        sprintf(end_input_str, "</%s%snodeName>",
 
1841
                                 p_prefix?p_prefix:"",
 
1842
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
1843
                        end_input_str_len = axutil_strlen(end_input_str);
 
1844
                    
 
1845
                           text_value_4 = _ncDescribeResourceResponseType->property_nodeName;
 
1846
                           
 
1847
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
1848
                           
 
1849
                            
 
1850
                           text_value_4_temp = axutil_xml_quote_string(env, text_value_4, AXIS2_TRUE);
 
1851
                           if (text_value_4_temp)
 
1852
                           {
 
1853
                               axutil_stream_write(stream, env, text_value_4_temp, axutil_strlen(text_value_4_temp));
 
1854
                               AXIS2_FREE(env->allocator, text_value_4_temp);
 
1855
                           }
 
1856
                           else
 
1857
                           {
 
1858
                               axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
 
1859
                           }
 
1860
                           
 
1861
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
1862
                           
 
1863
                     
 
1864
                     AXIS2_FREE(env->allocator,start_input_str);
 
1865
                     AXIS2_FREE(env->allocator,end_input_str);
 
1866
                 } 
 
1867
 
 
1868
                 
 
1869
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
1870
                       {
 
1871
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
1872
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
1873
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
1874
                           
 
1875
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
1876
                                            "http://eucalyptus.ucsb.edu/",
 
1877
                                            p_prefix));
 
1878
                       }
 
1879
                      
1791
1880
 
1792
1881
                   if (!_ncDescribeResourceResponseType->is_valid_statusMessage)
1793
1882
                   {
1794
 
 
 
1883
                      
1795
1884
                           /* no need to complain for minoccurs=0 element */
1796
 
 
1797
 
 
 
1885
                            
 
1886
                          
1798
1887
                   }
1799
1888
                   else
1800
1889
                   {
1801
1890
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1802
 
                                 (4 + axutil_strlen(p_prefix) +
1803
 
                                  axutil_strlen("statusMessage")));
1804
 
 
 
1891
                                 (4 + axutil_strlen(p_prefix) + 
 
1892
                                  axutil_strlen("statusMessage"))); 
 
1893
                                 
1805
1894
                                 /* axutil_strlen("<:>") + 1 = 4 */
1806
1895
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1807
1896
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1808
1897
                                  /* axutil_strlen("</:>") + 1 = 5 */
1809
 
 
1810
 
 
1811
 
 
1812
 
 
1813
 
 
1814
 
 
 
1898
                                  
 
1899
                     
 
1900
 
 
1901
                   
 
1902
                   
 
1903
                     
1815
1904
                     /*
1816
1905
                      * parsing statusMessage element
1817
1906
                      */
1818
1907
 
1819
 
 
1820
 
 
 
1908
                    
 
1909
                    
1821
1910
                            sprintf(start_input_str, "<%s%sstatusMessage>",
1822
1911
                                 p_prefix?p_prefix:"",
1823
1912
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1824
 
 
 
1913
                            
1825
1914
                        start_input_str_len = axutil_strlen(start_input_str);
1826
1915
                        sprintf(end_input_str, "</%s%sstatusMessage>",
1827
1916
                                 p_prefix?p_prefix:"",
1828
1917
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1829
1918
                        end_input_str_len = axutil_strlen(end_input_str);
1830
 
 
1831
 
                               sprintf (text_value_4, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_statusMessage);
1832
 
 
 
1919
                    
 
1920
                               sprintf (text_value_5, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_statusMessage);
 
1921
                             
1833
1922
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1834
 
 
1835
 
                           axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1836
 
 
 
1923
                           
 
1924
                           axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
 
1925
                           
1837
1926
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1838
 
 
1839
 
 
 
1927
                           
 
1928
                     
1840
1929
                     AXIS2_FREE(env->allocator,start_input_str);
1841
1930
                     AXIS2_FREE(env->allocator,end_input_str);
1842
 
                 }
1843
 
 
1844
 
 
 
1931
                 } 
 
1932
 
 
1933
                 
1845
1934
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1846
1935
                       {
1847
1936
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1848
1937
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1849
1938
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1850
 
 
 
1939
                           
1851
1940
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1852
1941
                                            "http://eucalyptus.ucsb.edu/",
1853
1942
                                            p_prefix));
1854
1943
                       }
1855
 
 
 
1944
                      
1856
1945
 
1857
1946
                   if (!_ncDescribeResourceResponseType->is_valid_nodeStatus)
1858
1947
                   {
1859
 
 
1860
 
 
 
1948
                      
 
1949
                            
1861
1950
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property nodeStatus");
1862
1951
                            return NULL;
1863
 
 
 
1952
                          
1864
1953
                   }
1865
1954
                   else
1866
1955
                   {
1867
1956
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1868
 
                                 (4 + axutil_strlen(p_prefix) +
1869
 
                                  axutil_strlen("nodeStatus")));
1870
 
 
 
1957
                                 (4 + axutil_strlen(p_prefix) + 
 
1958
                                  axutil_strlen("nodeStatus"))); 
 
1959
                                 
1871
1960
                                 /* axutil_strlen("<:>") + 1 = 4 */
1872
1961
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1873
1962
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("nodeStatus")));
1874
1963
                                  /* axutil_strlen("</:>") + 1 = 5 */
1875
 
 
1876
 
 
1877
 
 
1878
 
 
1879
 
 
1880
 
 
 
1964
                                  
 
1965
                     
 
1966
 
 
1967
                   
 
1968
                   
 
1969
                     
1881
1970
                     /*
1882
1971
                      * parsing nodeStatus element
1883
1972
                      */
1884
1973
 
1885
 
 
1886
 
 
 
1974
                    
 
1975
                    
1887
1976
                            sprintf(start_input_str, "<%s%snodeStatus>",
1888
1977
                                 p_prefix?p_prefix:"",
1889
1978
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1890
 
 
 
1979
                            
1891
1980
                        start_input_str_len = axutil_strlen(start_input_str);
1892
1981
                        sprintf(end_input_str, "</%s%snodeStatus>",
1893
1982
                                 p_prefix?p_prefix:"",
1894
1983
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1895
1984
                        end_input_str_len = axutil_strlen(end_input_str);
1896
 
 
1897
 
                           text_value_5 = _ncDescribeResourceResponseType->property_nodeStatus;
1898
 
 
 
1985
                    
 
1986
                           text_value_6 = _ncDescribeResourceResponseType->property_nodeStatus;
 
1987
                           
1899
1988
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1900
 
 
1901
 
 
1902
 
                           text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1903
 
                           if (text_value_5_temp)
 
1989
                           
 
1990
                            
 
1991
                           text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
 
1992
                           if (text_value_6_temp)
1904
1993
                           {
1905
 
                               axutil_stream_write(stream, env, text_value_5_temp, axutil_strlen(text_value_5_temp));
1906
 
                               AXIS2_FREE(env->allocator, text_value_5_temp);
 
1994
                               axutil_stream_write(stream, env, text_value_6_temp, axutil_strlen(text_value_6_temp));
 
1995
                               AXIS2_FREE(env->allocator, text_value_6_temp);
1907
1996
                           }
1908
1997
                           else
1909
1998
                           {
1910
 
                               axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
 
1999
                               axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1911
2000
                           }
1912
 
 
 
2001
                           
1913
2002
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1914
 
 
1915
 
 
 
2003
                           
 
2004
                     
1916
2005
                     AXIS2_FREE(env->allocator,start_input_str);
1917
2006
                     AXIS2_FREE(env->allocator,end_input_str);
1918
 
                 }
1919
 
 
1920
 
 
 
2007
                 } 
 
2008
 
 
2009
                 
1921
2010
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1922
2011
                       {
1923
2012
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1924
2013
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1925
2014
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1926
 
 
 
2015
                           
1927
2016
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1928
2017
                                            "http://eucalyptus.ucsb.edu/",
1929
2018
                                            p_prefix));
1930
2019
                       }
1931
 
 
 
2020
                      
1932
2021
 
1933
2022
                   if (!_ncDescribeResourceResponseType->is_valid_memorySizeMax)
1934
2023
                   {
1935
 
 
1936
 
 
 
2024
                      
 
2025
                            
1937
2026
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property memorySizeMax");
1938
2027
                            return NULL;
1939
 
 
 
2028
                          
1940
2029
                   }
1941
2030
                   else
1942
2031
                   {
1943
2032
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1944
 
                                 (4 + axutil_strlen(p_prefix) +
1945
 
                                  axutil_strlen("memorySizeMax")));
1946
 
 
 
2033
                                 (4 + axutil_strlen(p_prefix) + 
 
2034
                                  axutil_strlen("memorySizeMax"))); 
 
2035
                                 
1947
2036
                                 /* axutil_strlen("<:>") + 1 = 4 */
1948
2037
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1949
2038
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("memorySizeMax")));
1950
2039
                                  /* axutil_strlen("</:>") + 1 = 5 */
1951
 
 
1952
 
 
1953
 
 
1954
 
 
1955
 
 
1956
 
 
 
2040
                                  
 
2041
                     
 
2042
 
 
2043
                   
 
2044
                   
 
2045
                     
1957
2046
                     /*
1958
2047
                      * parsing memorySizeMax element
1959
2048
                      */
1960
2049
 
1961
 
 
1962
 
 
 
2050
                    
 
2051
                    
1963
2052
                            sprintf(start_input_str, "<%s%smemorySizeMax>",
1964
2053
                                 p_prefix?p_prefix:"",
1965
2054
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1966
 
 
 
2055
                            
1967
2056
                        start_input_str_len = axutil_strlen(start_input_str);
1968
2057
                        sprintf(end_input_str, "</%s%smemorySizeMax>",
1969
2058
                                 p_prefix?p_prefix:"",
1970
2059
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1971
2060
                        end_input_str_len = axutil_strlen(end_input_str);
1972
 
 
1973
 
                               sprintf (text_value_6, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_memorySizeMax);
1974
 
 
 
2061
                    
 
2062
                               sprintf (text_value_7, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_memorySizeMax);
 
2063
                             
1975
2064
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1976
 
 
1977
 
                           axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1978
 
 
 
2065
                           
 
2066
                           axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
 
2067
                           
1979
2068
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1980
 
 
1981
 
 
 
2069
                           
 
2070
                     
1982
2071
                     AXIS2_FREE(env->allocator,start_input_str);
1983
2072
                     AXIS2_FREE(env->allocator,end_input_str);
1984
 
                 }
1985
 
 
1986
 
 
 
2073
                 } 
 
2074
 
 
2075
                 
1987
2076
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1988
2077
                       {
1989
2078
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1990
2079
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1991
2080
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1992
 
 
 
2081
                           
1993
2082
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1994
2083
                                            "http://eucalyptus.ucsb.edu/",
1995
2084
                                            p_prefix));
1996
2085
                       }
1997
 
 
 
2086
                      
1998
2087
 
1999
2088
                   if (!_ncDescribeResourceResponseType->is_valid_memorySizeAvailable)
2000
2089
                   {
2001
 
 
2002
 
 
 
2090
                      
 
2091
                            
2003
2092
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property memorySizeAvailable");
2004
2093
                            return NULL;
2005
 
 
 
2094
                          
2006
2095
                   }
2007
2096
                   else
2008
2097
                   {
2009
2098
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2010
 
                                 (4 + axutil_strlen(p_prefix) +
2011
 
                                  axutil_strlen("memorySizeAvailable")));
2012
 
 
 
2099
                                 (4 + axutil_strlen(p_prefix) + 
 
2100
                                  axutil_strlen("memorySizeAvailable"))); 
 
2101
                                 
2013
2102
                                 /* axutil_strlen("<:>") + 1 = 4 */
2014
2103
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2015
2104
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("memorySizeAvailable")));
2016
2105
                                  /* axutil_strlen("</:>") + 1 = 5 */
2017
 
 
2018
 
 
2019
 
 
2020
 
 
2021
 
 
2022
 
 
 
2106
                                  
 
2107
                     
 
2108
 
 
2109
                   
 
2110
                   
 
2111
                     
2023
2112
                     /*
2024
2113
                      * parsing memorySizeAvailable element
2025
2114
                      */
2026
2115
 
2027
 
 
2028
 
 
 
2116
                    
 
2117
                    
2029
2118
                            sprintf(start_input_str, "<%s%smemorySizeAvailable>",
2030
2119
                                 p_prefix?p_prefix:"",
2031
2120
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2032
 
 
 
2121
                            
2033
2122
                        start_input_str_len = axutil_strlen(start_input_str);
2034
2123
                        sprintf(end_input_str, "</%s%smemorySizeAvailable>",
2035
2124
                                 p_prefix?p_prefix:"",
2036
2125
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2037
2126
                        end_input_str_len = axutil_strlen(end_input_str);
2038
 
 
2039
 
                               sprintf (text_value_7, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_memorySizeAvailable);
2040
 
 
 
2127
                    
 
2128
                               sprintf (text_value_8, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_memorySizeAvailable);
 
2129
                             
2041
2130
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2042
 
 
2043
 
                           axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
2044
 
 
 
2131
                           
 
2132
                           axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
 
2133
                           
2045
2134
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2046
 
 
2047
 
 
 
2135
                           
 
2136
                     
2048
2137
                     AXIS2_FREE(env->allocator,start_input_str);
2049
2138
                     AXIS2_FREE(env->allocator,end_input_str);
2050
 
                 }
2051
 
 
2052
 
 
 
2139
                 } 
 
2140
 
 
2141
                 
2053
2142
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2054
2143
                       {
2055
2144
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2056
2145
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
2057
2146
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2058
 
 
 
2147
                           
2059
2148
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2060
2149
                                            "http://eucalyptus.ucsb.edu/",
2061
2150
                                            p_prefix));
2062
2151
                       }
2063
 
 
 
2152
                      
2064
2153
 
2065
2154
                   if (!_ncDescribeResourceResponseType->is_valid_diskSizeMax)
2066
2155
                   {
2067
 
 
2068
 
 
 
2156
                      
 
2157
                            
2069
2158
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property diskSizeMax");
2070
2159
                            return NULL;
2071
 
 
 
2160
                          
2072
2161
                   }
2073
2162
                   else
2074
2163
                   {
2075
2164
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2076
 
                                 (4 + axutil_strlen(p_prefix) +
2077
 
                                  axutil_strlen("diskSizeMax")));
2078
 
 
 
2165
                                 (4 + axutil_strlen(p_prefix) + 
 
2166
                                  axutil_strlen("diskSizeMax"))); 
 
2167
                                 
2079
2168
                                 /* axutil_strlen("<:>") + 1 = 4 */
2080
2169
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2081
2170
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("diskSizeMax")));
2082
2171
                                  /* axutil_strlen("</:>") + 1 = 5 */
2083
 
 
2084
 
 
2085
 
 
2086
 
 
2087
 
 
2088
 
 
 
2172
                                  
 
2173
                     
 
2174
 
 
2175
                   
 
2176
                   
 
2177
                     
2089
2178
                     /*
2090
2179
                      * parsing diskSizeMax element
2091
2180
                      */
2092
2181
 
2093
 
 
2094
 
 
 
2182
                    
 
2183
                    
2095
2184
                            sprintf(start_input_str, "<%s%sdiskSizeMax>",
2096
2185
                                 p_prefix?p_prefix:"",
2097
2186
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2098
 
 
 
2187
                            
2099
2188
                        start_input_str_len = axutil_strlen(start_input_str);
2100
2189
                        sprintf(end_input_str, "</%s%sdiskSizeMax>",
2101
2190
                                 p_prefix?p_prefix:"",
2102
2191
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2103
2192
                        end_input_str_len = axutil_strlen(end_input_str);
2104
 
 
2105
 
                               sprintf (text_value_8, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_diskSizeMax);
2106
 
 
 
2193
                    
 
2194
                               sprintf (text_value_9, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_diskSizeMax);
 
2195
                             
2107
2196
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2108
 
 
2109
 
                           axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
2110
 
 
 
2197
                           
 
2198
                           axutil_stream_write(stream, env, text_value_9, axutil_strlen(text_value_9));
 
2199
                           
2111
2200
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2112
 
 
2113
 
 
 
2201
                           
 
2202
                     
2114
2203
                     AXIS2_FREE(env->allocator,start_input_str);
2115
2204
                     AXIS2_FREE(env->allocator,end_input_str);
2116
 
                 }
2117
 
 
2118
 
 
 
2205
                 } 
 
2206
 
 
2207
                 
2119
2208
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2120
2209
                       {
2121
2210
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2122
2211
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
2123
2212
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2124
 
 
 
2213
                           
2125
2214
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2126
2215
                                            "http://eucalyptus.ucsb.edu/",
2127
2216
                                            p_prefix));
2128
2217
                       }
2129
 
 
 
2218
                      
2130
2219
 
2131
2220
                   if (!_ncDescribeResourceResponseType->is_valid_diskSizeAvailable)
2132
2221
                   {
2133
 
 
2134
 
 
 
2222
                      
 
2223
                            
2135
2224
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property diskSizeAvailable");
2136
2225
                            return NULL;
2137
 
 
 
2226
                          
2138
2227
                   }
2139
2228
                   else
2140
2229
                   {
2141
2230
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2142
 
                                 (4 + axutil_strlen(p_prefix) +
2143
 
                                  axutil_strlen("diskSizeAvailable")));
2144
 
 
 
2231
                                 (4 + axutil_strlen(p_prefix) + 
 
2232
                                  axutil_strlen("diskSizeAvailable"))); 
 
2233
                                 
2145
2234
                                 /* axutil_strlen("<:>") + 1 = 4 */
2146
2235
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2147
2236
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("diskSizeAvailable")));
2148
2237
                                  /* axutil_strlen("</:>") + 1 = 5 */
2149
 
 
2150
 
 
2151
 
 
2152
 
 
2153
 
 
2154
 
 
 
2238
                                  
 
2239
                     
 
2240
 
 
2241
                   
 
2242
                   
 
2243
                     
2155
2244
                     /*
2156
2245
                      * parsing diskSizeAvailable element
2157
2246
                      */
2158
2247
 
2159
 
 
2160
 
 
 
2248
                    
 
2249
                    
2161
2250
                            sprintf(start_input_str, "<%s%sdiskSizeAvailable>",
2162
2251
                                 p_prefix?p_prefix:"",
2163
2252
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2164
 
 
 
2253
                            
2165
2254
                        start_input_str_len = axutil_strlen(start_input_str);
2166
2255
                        sprintf(end_input_str, "</%s%sdiskSizeAvailable>",
2167
2256
                                 p_prefix?p_prefix:"",
2168
2257
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2169
2258
                        end_input_str_len = axutil_strlen(end_input_str);
2170
 
 
2171
 
                               sprintf (text_value_9, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_diskSizeAvailable);
2172
 
 
 
2259
                    
 
2260
                               sprintf (text_value_10, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_diskSizeAvailable);
 
2261
                             
2173
2262
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2174
 
 
2175
 
                           axutil_stream_write(stream, env, text_value_9, axutil_strlen(text_value_9));
2176
 
 
 
2263
                           
 
2264
                           axutil_stream_write(stream, env, text_value_10, axutil_strlen(text_value_10));
 
2265
                           
2177
2266
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2178
 
 
2179
 
 
 
2267
                           
 
2268
                     
2180
2269
                     AXIS2_FREE(env->allocator,start_input_str);
2181
2270
                     AXIS2_FREE(env->allocator,end_input_str);
2182
 
                 }
2183
 
 
2184
 
 
 
2271
                 } 
 
2272
 
 
2273
                 
2185
2274
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2186
2275
                       {
2187
2276
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2188
2277
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
2189
2278
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2190
 
 
 
2279
                           
2191
2280
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2192
2281
                                            "http://eucalyptus.ucsb.edu/",
2193
2282
                                            p_prefix));
2194
2283
                       }
2195
 
 
 
2284
                      
2196
2285
 
2197
2286
                   if (!_ncDescribeResourceResponseType->is_valid_numberOfCoresMax)
2198
2287
                   {
2199
 
 
2200
 
 
 
2288
                      
 
2289
                            
2201
2290
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property numberOfCoresMax");
2202
2291
                            return NULL;
2203
 
 
 
2292
                          
2204
2293
                   }
2205
2294
                   else
2206
2295
                   {
2207
2296
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2208
 
                                 (4 + axutil_strlen(p_prefix) +
2209
 
                                  axutil_strlen("numberOfCoresMax")));
2210
 
 
 
2297
                                 (4 + axutil_strlen(p_prefix) + 
 
2298
                                  axutil_strlen("numberOfCoresMax"))); 
 
2299
                                 
2211
2300
                                 /* axutil_strlen("<:>") + 1 = 4 */
2212
2301
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2213
2302
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("numberOfCoresMax")));
2214
2303
                                  /* axutil_strlen("</:>") + 1 = 5 */
2215
 
 
2216
 
 
2217
 
 
2218
 
 
2219
 
 
2220
 
 
 
2304
                                  
 
2305
                     
 
2306
 
 
2307
                   
 
2308
                   
 
2309
                     
2221
2310
                     /*
2222
2311
                      * parsing numberOfCoresMax element
2223
2312
                      */
2224
2313
 
2225
 
 
2226
 
 
 
2314
                    
 
2315
                    
2227
2316
                            sprintf(start_input_str, "<%s%snumberOfCoresMax>",
2228
2317
                                 p_prefix?p_prefix:"",
2229
2318
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2230
 
 
 
2319
                            
2231
2320
                        start_input_str_len = axutil_strlen(start_input_str);
2232
2321
                        sprintf(end_input_str, "</%s%snumberOfCoresMax>",
2233
2322
                                 p_prefix?p_prefix:"",
2234
2323
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2235
2324
                        end_input_str_len = axutil_strlen(end_input_str);
2236
 
 
2237
 
                               sprintf (text_value_10, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_numberOfCoresMax);
2238
 
 
 
2325
                    
 
2326
                               sprintf (text_value_11, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_numberOfCoresMax);
 
2327
                             
2239
2328
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2240
 
 
2241
 
                           axutil_stream_write(stream, env, text_value_10, axutil_strlen(text_value_10));
2242
 
 
 
2329
                           
 
2330
                           axutil_stream_write(stream, env, text_value_11, axutil_strlen(text_value_11));
 
2331
                           
2243
2332
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2244
 
 
2245
 
 
 
2333
                           
 
2334
                     
2246
2335
                     AXIS2_FREE(env->allocator,start_input_str);
2247
2336
                     AXIS2_FREE(env->allocator,end_input_str);
2248
 
                 }
2249
 
 
2250
 
 
 
2337
                 } 
 
2338
 
 
2339
                 
2251
2340
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2252
2341
                       {
2253
2342
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2254
2343
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
2255
2344
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2256
 
 
 
2345
                           
2257
2346
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2258
2347
                                            "http://eucalyptus.ucsb.edu/",
2259
2348
                                            p_prefix));
2260
2349
                       }
2261
 
 
 
2350
                      
2262
2351
 
2263
2352
                   if (!_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable)
2264
2353
                   {
2265
 
 
2266
 
 
 
2354
                      
 
2355
                            
2267
2356
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property numberOfCoresAvailable");
2268
2357
                            return NULL;
2269
 
 
 
2358
                          
2270
2359
                   }
2271
2360
                   else
2272
2361
                   {
2273
2362
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2274
 
                                 (4 + axutil_strlen(p_prefix) +
2275
 
                                  axutil_strlen("numberOfCoresAvailable")));
2276
 
 
 
2363
                                 (4 + axutil_strlen(p_prefix) + 
 
2364
                                  axutil_strlen("numberOfCoresAvailable"))); 
 
2365
                                 
2277
2366
                                 /* axutil_strlen("<:>") + 1 = 4 */
2278
2367
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2279
2368
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("numberOfCoresAvailable")));
2280
2369
                                  /* axutil_strlen("</:>") + 1 = 5 */
2281
 
 
2282
 
 
2283
 
 
2284
 
 
2285
 
 
2286
 
 
 
2370
                                  
 
2371
                     
 
2372
 
 
2373
                   
 
2374
                   
 
2375
                     
2287
2376
                     /*
2288
2377
                      * parsing numberOfCoresAvailable element
2289
2378
                      */
2290
2379
 
2291
 
 
2292
 
 
 
2380
                    
 
2381
                    
2293
2382
                            sprintf(start_input_str, "<%s%snumberOfCoresAvailable>",
2294
2383
                                 p_prefix?p_prefix:"",
2295
2384
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2296
 
 
 
2385
                            
2297
2386
                        start_input_str_len = axutil_strlen(start_input_str);
2298
2387
                        sprintf(end_input_str, "</%s%snumberOfCoresAvailable>",
2299
2388
                                 p_prefix?p_prefix:"",
2300
2389
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2301
2390
                        end_input_str_len = axutil_strlen(end_input_str);
2302
 
 
2303
 
                               sprintf (text_value_11, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_numberOfCoresAvailable);
2304
 
 
 
2391
                    
 
2392
                               sprintf (text_value_12, AXIS2_PRINTF_INT32_FORMAT_SPECIFIER, _ncDescribeResourceResponseType->property_numberOfCoresAvailable);
 
2393
                             
2305
2394
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2306
 
 
2307
 
                           axutil_stream_write(stream, env, text_value_11, axutil_strlen(text_value_11));
2308
 
 
 
2395
                           
 
2396
                           axutil_stream_write(stream, env, text_value_12, axutil_strlen(text_value_12));
 
2397
                           
2309
2398
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2310
 
 
2311
 
 
 
2399
                           
 
2400
                     
2312
2401
                     AXIS2_FREE(env->allocator,start_input_str);
2313
2402
                     AXIS2_FREE(env->allocator,end_input_str);
2314
 
                 }
2315
 
 
2316
 
 
 
2403
                 } 
 
2404
 
 
2405
                 
2317
2406
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
2318
2407
                       {
2319
2408
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
2320
2409
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
2321
2410
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
2322
 
 
 
2411
                           
2323
2412
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
2324
2413
                                            "http://eucalyptus.ucsb.edu/",
2325
2414
                                            p_prefix));
2326
2415
                       }
2327
 
 
 
2416
                      
2328
2417
 
2329
2418
                   if (!_ncDescribeResourceResponseType->is_valid_publicSubnets)
2330
2419
                   {
2331
 
 
2332
 
 
 
2420
                      
 
2421
                            
2333
2422
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property publicSubnets");
2334
2423
                            return NULL;
2335
 
 
 
2424
                          
2336
2425
                   }
2337
2426
                   else
2338
2427
                   {
2339
2428
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2340
 
                                 (4 + axutil_strlen(p_prefix) +
2341
 
                                  axutil_strlen("publicSubnets")));
2342
 
 
 
2429
                                 (4 + axutil_strlen(p_prefix) + 
 
2430
                                  axutil_strlen("publicSubnets"))); 
 
2431
                                 
2343
2432
                                 /* axutil_strlen("<:>") + 1 = 4 */
2344
2433
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
2345
2434
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("publicSubnets")));
2346
2435
                                  /* axutil_strlen("</:>") + 1 = 5 */
2347
 
 
2348
 
 
2349
 
 
2350
 
 
2351
 
 
2352
 
 
 
2436
                                  
 
2437
                     
 
2438
 
 
2439
                   
 
2440
                   
 
2441
                     
2353
2442
                     /*
2354
2443
                      * parsing publicSubnets element
2355
2444
                      */
2356
2445
 
2357
 
 
2358
 
 
 
2446
                    
 
2447
                    
2359
2448
                            sprintf(start_input_str, "<%s%spublicSubnets>",
2360
2449
                                 p_prefix?p_prefix:"",
2361
2450
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2362
 
 
 
2451
                            
2363
2452
                        start_input_str_len = axutil_strlen(start_input_str);
2364
2453
                        sprintf(end_input_str, "</%s%spublicSubnets>",
2365
2454
                                 p_prefix?p_prefix:"",
2366
2455
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2367
2456
                        end_input_str_len = axutil_strlen(end_input_str);
2368
 
 
2369
 
                           text_value_12 = _ncDescribeResourceResponseType->property_publicSubnets;
2370
 
 
 
2457
                    
 
2458
                           text_value_13 = _ncDescribeResourceResponseType->property_publicSubnets;
 
2459
                           
2371
2460
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2372
 
 
2373
 
 
2374
 
                           text_value_12_temp = axutil_xml_quote_string(env, text_value_12, AXIS2_TRUE);
2375
 
                           if (text_value_12_temp)
 
2461
                           
 
2462
                            
 
2463
                           text_value_13_temp = axutil_xml_quote_string(env, text_value_13, AXIS2_TRUE);
 
2464
                           if (text_value_13_temp)
2376
2465
                           {
2377
 
                               axutil_stream_write(stream, env, text_value_12_temp, axutil_strlen(text_value_12_temp));
2378
 
                               AXIS2_FREE(env->allocator, text_value_12_temp);
 
2466
                               axutil_stream_write(stream, env, text_value_13_temp, axutil_strlen(text_value_13_temp));
 
2467
                               AXIS2_FREE(env->allocator, text_value_13_temp);
2379
2468
                           }
2380
2469
                           else
2381
2470
                           {
2382
 
                               axutil_stream_write(stream, env, text_value_12, axutil_strlen(text_value_12));
 
2471
                               axutil_stream_write(stream, env, text_value_13, axutil_strlen(text_value_13));
2383
2472
                           }
2384
 
 
 
2473
                           
2385
2474
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2386
 
 
2387
 
 
 
2475
                           
 
2476
                     
2388
2477
                     AXIS2_FREE(env->allocator,start_input_str);
2389
2478
                     AXIS2_FREE(env->allocator,end_input_str);
2390
 
                 }
2391
 
 
2392
 
 
 
2479
                 } 
 
2480
 
 
2481
                 
2393
2482
 
2394
2483
            return parent;
2395
2484
        }
2396
2485
 
2397
2486
 
2398
 
 
 
2487
        
2399
2488
 
2400
2489
            /**
2401
2490
             * getter for correlationId.
2405
2494
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2406
2495
                    const axutil_env_t *env)
2407
2496
             {
2408
 
 
 
2497
                
2409
2498
                    AXIS2_ENV_CHECK(env, NULL);
2410
2499
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
2411
 
 
 
2500
                  
2412
2501
 
2413
2502
                return _ncDescribeResourceResponseType->property_correlationId;
2414
2503
             }
2422
2511
                    const axutil_env_t *env,
2423
2512
                    const axis2_char_t*  arg_correlationId)
2424
2513
             {
2425
 
 
 
2514
                
2426
2515
 
2427
2516
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2428
2517
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2429
 
 
 
2518
                
2430
2519
                if(_ncDescribeResourceResponseType->is_valid_correlationId &&
2431
2520
                        arg_correlationId == _ncDescribeResourceResponseType->property_correlationId)
2432
2521
                {
2433
 
 
2434
 
                    return AXIS2_SUCCESS;
 
2522
                    
 
2523
                    return AXIS2_SUCCESS; 
2435
2524
                }
2436
2525
 
2437
2526
                adb_ncDescribeResourceResponseType_reset_correlationId(_ncDescribeResourceResponseType, env);
2438
2527
 
2439
 
 
 
2528
                
2440
2529
                if(NULL == arg_correlationId)
2441
2530
                {
2442
2531
                    /* We are already done */
2449
2538
                            return AXIS2_FAILURE;
2450
2539
                        }
2451
2540
                        _ncDescribeResourceResponseType->is_valid_correlationId = AXIS2_TRUE;
2452
 
 
 
2541
                    
2453
2542
                return AXIS2_SUCCESS;
2454
2543
             }
2455
2544
 
2456
 
 
 
2545
             
2457
2546
 
2458
2547
           /**
2459
2548
            * resetter for correlationId
2469
2558
 
2470
2559
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2471
2560
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2472
 
 
2473
 
 
2474
 
 
2475
 
 
2476
 
 
 
2561
               
 
2562
 
 
2563
               
 
2564
            
 
2565
                
2477
2566
                if(_ncDescribeResourceResponseType->property_correlationId != NULL)
2478
2567
                {
2479
 
 
2480
 
 
 
2568
                   
 
2569
                   
2481
2570
                        AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_correlationId);
2482
2571
                     _ncDescribeResourceResponseType->property_correlationId = NULL;
2483
2572
                }
2484
 
 
2485
 
 
2486
 
 
2487
 
                _ncDescribeResourceResponseType->is_valid_correlationId = AXIS2_FALSE;
 
2573
            
 
2574
                
 
2575
                
 
2576
                _ncDescribeResourceResponseType->is_valid_correlationId = AXIS2_FALSE; 
2488
2577
               return AXIS2_SUCCESS;
2489
2578
           }
2490
2579
 
2498
2587
           {
2499
2588
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2500
2589
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2501
 
 
 
2590
               
2502
2591
               return !_ncDescribeResourceResponseType->is_valid_correlationId;
2503
2592
           }
2504
2593
 
2513
2602
               return adb_ncDescribeResourceResponseType_reset_correlationId(_ncDescribeResourceResponseType, env);
2514
2603
           }
2515
2604
 
2516
 
 
 
2605
           
2517
2606
 
2518
2607
            /**
2519
2608
             * getter for userId.
2523
2612
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2524
2613
                    const axutil_env_t *env)
2525
2614
             {
2526
 
 
 
2615
                
2527
2616
                    AXIS2_ENV_CHECK(env, NULL);
2528
2617
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
2529
 
 
 
2618
                  
2530
2619
 
2531
2620
                return _ncDescribeResourceResponseType->property_userId;
2532
2621
             }
2540
2629
                    const axutil_env_t *env,
2541
2630
                    const axis2_char_t*  arg_userId)
2542
2631
             {
2543
 
 
 
2632
                
2544
2633
 
2545
2634
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2546
2635
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2547
 
 
 
2636
                
2548
2637
                if(_ncDescribeResourceResponseType->is_valid_userId &&
2549
2638
                        arg_userId == _ncDescribeResourceResponseType->property_userId)
2550
2639
                {
2551
 
 
2552
 
                    return AXIS2_SUCCESS;
 
2640
                    
 
2641
                    return AXIS2_SUCCESS; 
2553
2642
                }
2554
2643
 
2555
2644
                adb_ncDescribeResourceResponseType_reset_userId(_ncDescribeResourceResponseType, env);
2556
2645
 
2557
 
 
 
2646
                
2558
2647
                if(NULL == arg_userId)
2559
2648
                {
2560
2649
                    /* We are already done */
2567
2656
                            return AXIS2_FAILURE;
2568
2657
                        }
2569
2658
                        _ncDescribeResourceResponseType->is_valid_userId = AXIS2_TRUE;
2570
 
 
 
2659
                    
2571
2660
                return AXIS2_SUCCESS;
2572
2661
             }
2573
2662
 
2574
 
 
 
2663
             
2575
2664
 
2576
2665
           /**
2577
2666
            * resetter for userId
2587
2676
 
2588
2677
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2589
2678
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2590
 
 
2591
 
 
2592
 
 
2593
 
 
2594
 
 
 
2679
               
 
2680
 
 
2681
               
 
2682
            
 
2683
                
2595
2684
                if(_ncDescribeResourceResponseType->property_userId != NULL)
2596
2685
                {
2597
 
 
2598
 
 
 
2686
                   
 
2687
                   
2599
2688
                        AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_userId);
2600
2689
                     _ncDescribeResourceResponseType->property_userId = NULL;
2601
2690
                }
2602
 
 
2603
 
 
2604
 
 
2605
 
                _ncDescribeResourceResponseType->is_valid_userId = AXIS2_FALSE;
 
2691
            
 
2692
                
 
2693
                
 
2694
                _ncDescribeResourceResponseType->is_valid_userId = AXIS2_FALSE; 
2606
2695
               return AXIS2_SUCCESS;
2607
2696
           }
2608
2697
 
2616
2705
           {
2617
2706
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2618
2707
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2619
 
 
 
2708
               
2620
2709
               return !_ncDescribeResourceResponseType->is_valid_userId;
2621
2710
           }
2622
2711
 
2631
2720
               return adb_ncDescribeResourceResponseType_reset_userId(_ncDescribeResourceResponseType, env);
2632
2721
           }
2633
2722
 
2634
 
 
 
2723
           
2635
2724
 
2636
2725
            /**
2637
2726
             * getter for return.
2641
2730
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2642
2731
                    const axutil_env_t *env)
2643
2732
             {
2644
 
 
 
2733
                
2645
2734
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
2646
2735
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (axis2_bool_t)0);
2647
 
 
 
2736
                  
2648
2737
 
2649
2738
                return _ncDescribeResourceResponseType->property_return;
2650
2739
             }
2658
2747
                    const axutil_env_t *env,
2659
2748
                    axis2_bool_t  arg_return)
2660
2749
             {
2661
 
 
 
2750
                
2662
2751
 
2663
2752
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2664
2753
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2665
 
 
 
2754
                
2666
2755
                if(_ncDescribeResourceResponseType->is_valid_return &&
2667
2756
                        arg_return == _ncDescribeResourceResponseType->property_return)
2668
2757
                {
2669
 
 
2670
 
                    return AXIS2_SUCCESS;
 
2758
                    
 
2759
                    return AXIS2_SUCCESS; 
2671
2760
                }
2672
2761
 
2673
2762
                adb_ncDescribeResourceResponseType_reset_return(_ncDescribeResourceResponseType, env);
2674
2763
 
2675
2764
                _ncDescribeResourceResponseType->property_return = arg_return;
2676
2765
                        _ncDescribeResourceResponseType->is_valid_return = AXIS2_TRUE;
2677
 
 
 
2766
                    
2678
2767
                return AXIS2_SUCCESS;
2679
2768
             }
2680
2769
 
2681
 
 
 
2770
             
2682
2771
 
2683
2772
           /**
2684
2773
            * resetter for return
2694
2783
 
2695
2784
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2696
2785
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2697
 
 
2698
 
 
2699
 
               _ncDescribeResourceResponseType->is_valid_return = AXIS2_FALSE;
 
2786
               
 
2787
 
 
2788
               _ncDescribeResourceResponseType->is_valid_return = AXIS2_FALSE; 
2700
2789
               return AXIS2_SUCCESS;
2701
2790
           }
2702
2791
 
2710
2799
           {
2711
2800
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2712
2801
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2713
 
 
 
2802
               
2714
2803
               return !_ncDescribeResourceResponseType->is_valid_return;
2715
2804
           }
2716
2805
 
2725
2814
               return adb_ncDescribeResourceResponseType_reset_return(_ncDescribeResourceResponseType, env);
2726
2815
           }
2727
2816
 
2728
 
 
 
2817
           
 
2818
 
 
2819
            /**
 
2820
             * getter for nodeName.
 
2821
             */
 
2822
            axis2_char_t* AXIS2_CALL
 
2823
            adb_ncDescribeResourceResponseType_get_nodeName(
 
2824
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
 
2825
                    const axutil_env_t *env)
 
2826
             {
 
2827
                
 
2828
                    AXIS2_ENV_CHECK(env, NULL);
 
2829
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
 
2830
                  
 
2831
 
 
2832
                return _ncDescribeResourceResponseType->property_nodeName;
 
2833
             }
 
2834
 
 
2835
            /**
 
2836
             * setter for nodeName
 
2837
             */
 
2838
            axis2_status_t AXIS2_CALL
 
2839
            adb_ncDescribeResourceResponseType_set_nodeName(
 
2840
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
 
2841
                    const axutil_env_t *env,
 
2842
                    const axis2_char_t*  arg_nodeName)
 
2843
             {
 
2844
                
 
2845
 
 
2846
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
2847
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
 
2848
                
 
2849
                if(_ncDescribeResourceResponseType->is_valid_nodeName &&
 
2850
                        arg_nodeName == _ncDescribeResourceResponseType->property_nodeName)
 
2851
                {
 
2852
                    
 
2853
                    return AXIS2_SUCCESS; 
 
2854
                }
 
2855
 
 
2856
                adb_ncDescribeResourceResponseType_reset_nodeName(_ncDescribeResourceResponseType, env);
 
2857
 
 
2858
                
 
2859
                if(NULL == arg_nodeName)
 
2860
                {
 
2861
                    /* We are already done */
 
2862
                    return AXIS2_SUCCESS;
 
2863
                }
 
2864
                _ncDescribeResourceResponseType->property_nodeName = (axis2_char_t *)axutil_strdup(env, arg_nodeName);
 
2865
                        if(NULL == _ncDescribeResourceResponseType->property_nodeName)
 
2866
                        {
 
2867
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for nodeName");
 
2868
                            return AXIS2_FAILURE;
 
2869
                        }
 
2870
                        _ncDescribeResourceResponseType->is_valid_nodeName = AXIS2_TRUE;
 
2871
                    
 
2872
                return AXIS2_SUCCESS;
 
2873
             }
 
2874
 
 
2875
             
 
2876
 
 
2877
           /**
 
2878
            * resetter for nodeName
 
2879
            */
 
2880
           axis2_status_t AXIS2_CALL
 
2881
           adb_ncDescribeResourceResponseType_reset_nodeName(
 
2882
                   adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
 
2883
                   const axutil_env_t *env)
 
2884
           {
 
2885
               int i = 0;
 
2886
               int count = 0;
 
2887
               void *element = NULL;
 
2888
 
 
2889
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
2890
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
 
2891
               
 
2892
 
 
2893
               
 
2894
            
 
2895
                
 
2896
                if(_ncDescribeResourceResponseType->property_nodeName != NULL)
 
2897
                {
 
2898
                   
 
2899
                   
 
2900
                        AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_nodeName);
 
2901
                     _ncDescribeResourceResponseType->property_nodeName = NULL;
 
2902
                }
 
2903
            
 
2904
                
 
2905
                
 
2906
                _ncDescribeResourceResponseType->is_valid_nodeName = AXIS2_FALSE; 
 
2907
               return AXIS2_SUCCESS;
 
2908
           }
 
2909
 
 
2910
           /**
 
2911
            * Check whether nodeName is nill
 
2912
            */
 
2913
           axis2_bool_t AXIS2_CALL
 
2914
           adb_ncDescribeResourceResponseType_is_nodeName_nil(
 
2915
                   adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
 
2916
                   const axutil_env_t *env)
 
2917
           {
 
2918
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
2919
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
 
2920
               
 
2921
               return !_ncDescribeResourceResponseType->is_valid_nodeName;
 
2922
           }
 
2923
 
 
2924
           /**
 
2925
            * Set nodeName to nill (currently the same as reset)
 
2926
            */
 
2927
           axis2_status_t AXIS2_CALL
 
2928
           adb_ncDescribeResourceResponseType_set_nodeName_nil(
 
2929
                   adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
 
2930
                   const axutil_env_t *env)
 
2931
           {
 
2932
               return adb_ncDescribeResourceResponseType_reset_nodeName(_ncDescribeResourceResponseType, env);
 
2933
           }
 
2934
 
 
2935
           
2729
2936
 
2730
2937
            /**
2731
2938
             * getter for statusMessage.
2735
2942
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2736
2943
                    const axutil_env_t *env)
2737
2944
             {
2738
 
 
 
2945
                
2739
2946
                    AXIS2_ENV_CHECK(env, (int)0);
2740
2947
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
2741
 
 
 
2948
                  
2742
2949
 
2743
2950
                return _ncDescribeResourceResponseType->property_statusMessage;
2744
2951
             }
2752
2959
                    const axutil_env_t *env,
2753
2960
                    const int  arg_statusMessage)
2754
2961
             {
2755
 
 
 
2962
                
2756
2963
 
2757
2964
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2758
2965
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2759
 
 
 
2966
                
2760
2967
                if(_ncDescribeResourceResponseType->is_valid_statusMessage &&
2761
2968
                        arg_statusMessage == _ncDescribeResourceResponseType->property_statusMessage)
2762
2969
                {
2763
 
 
2764
 
                    return AXIS2_SUCCESS;
 
2970
                    
 
2971
                    return AXIS2_SUCCESS; 
2765
2972
                }
2766
2973
 
2767
2974
                adb_ncDescribeResourceResponseType_reset_statusMessage(_ncDescribeResourceResponseType, env);
2768
2975
 
2769
2976
                _ncDescribeResourceResponseType->property_statusMessage = arg_statusMessage;
2770
2977
                        _ncDescribeResourceResponseType->is_valid_statusMessage = AXIS2_TRUE;
2771
 
 
 
2978
                    
2772
2979
                return AXIS2_SUCCESS;
2773
2980
             }
2774
2981
 
2775
 
 
 
2982
             
2776
2983
 
2777
2984
           /**
2778
2985
            * resetter for statusMessage
2788
2995
 
2789
2996
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2790
2997
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2791
 
 
2792
 
 
2793
 
               _ncDescribeResourceResponseType->is_valid_statusMessage = AXIS2_FALSE;
 
2998
               
 
2999
 
 
3000
               _ncDescribeResourceResponseType->is_valid_statusMessage = AXIS2_FALSE; 
2794
3001
               return AXIS2_SUCCESS;
2795
3002
           }
2796
3003
 
2804
3011
           {
2805
3012
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2806
3013
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2807
 
 
 
3014
               
2808
3015
               return !_ncDescribeResourceResponseType->is_valid_statusMessage;
2809
3016
           }
2810
3017
 
2819
3026
               return adb_ncDescribeResourceResponseType_reset_statusMessage(_ncDescribeResourceResponseType, env);
2820
3027
           }
2821
3028
 
2822
 
 
 
3029
           
2823
3030
 
2824
3031
            /**
2825
3032
             * getter for nodeStatus.
2829
3036
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2830
3037
                    const axutil_env_t *env)
2831
3038
             {
2832
 
 
 
3039
                
2833
3040
                    AXIS2_ENV_CHECK(env, NULL);
2834
3041
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
2835
 
 
 
3042
                  
2836
3043
 
2837
3044
                return _ncDescribeResourceResponseType->property_nodeStatus;
2838
3045
             }
2846
3053
                    const axutil_env_t *env,
2847
3054
                    const axis2_char_t*  arg_nodeStatus)
2848
3055
             {
2849
 
 
 
3056
                
2850
3057
 
2851
3058
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2852
3059
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2853
 
 
 
3060
                
2854
3061
                if(_ncDescribeResourceResponseType->is_valid_nodeStatus &&
2855
3062
                        arg_nodeStatus == _ncDescribeResourceResponseType->property_nodeStatus)
2856
3063
                {
2857
 
 
2858
 
                    return AXIS2_SUCCESS;
 
3064
                    
 
3065
                    return AXIS2_SUCCESS; 
2859
3066
                }
2860
3067
 
2861
 
 
 
3068
                
2862
3069
                  if(NULL == arg_nodeStatus)
2863
3070
                  {
2864
3071
                      AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "nodeStatus is being set to NULL, but it is not a nullable element");
2866
3073
                  }
2867
3074
                adb_ncDescribeResourceResponseType_reset_nodeStatus(_ncDescribeResourceResponseType, env);
2868
3075
 
2869
 
 
 
3076
                
2870
3077
                if(NULL == arg_nodeStatus)
2871
3078
                {
2872
3079
                    /* We are already done */
2879
3086
                            return AXIS2_FAILURE;
2880
3087
                        }
2881
3088
                        _ncDescribeResourceResponseType->is_valid_nodeStatus = AXIS2_TRUE;
2882
 
 
 
3089
                    
2883
3090
                return AXIS2_SUCCESS;
2884
3091
             }
2885
3092
 
2886
 
 
 
3093
             
2887
3094
 
2888
3095
           /**
2889
3096
            * resetter for nodeStatus
2899
3106
 
2900
3107
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2901
3108
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2902
 
 
2903
 
 
2904
 
 
2905
 
 
2906
 
 
 
3109
               
 
3110
 
 
3111
               
 
3112
            
 
3113
                
2907
3114
                if(_ncDescribeResourceResponseType->property_nodeStatus != NULL)
2908
3115
                {
2909
 
 
2910
 
 
 
3116
                   
 
3117
                   
2911
3118
                        AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_nodeStatus);
2912
3119
                     _ncDescribeResourceResponseType->property_nodeStatus = NULL;
2913
3120
                }
2914
 
 
2915
 
 
2916
 
 
2917
 
                _ncDescribeResourceResponseType->is_valid_nodeStatus = AXIS2_FALSE;
 
3121
            
 
3122
                
 
3123
                
 
3124
                _ncDescribeResourceResponseType->is_valid_nodeStatus = AXIS2_FALSE; 
2918
3125
               return AXIS2_SUCCESS;
2919
3126
           }
2920
3127
 
2928
3135
           {
2929
3136
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2930
3137
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
2931
 
 
 
3138
               
2932
3139
               return !_ncDescribeResourceResponseType->is_valid_nodeStatus;
2933
3140
           }
2934
3141
 
2943
3150
               return adb_ncDescribeResourceResponseType_reset_nodeStatus(_ncDescribeResourceResponseType, env);
2944
3151
           }
2945
3152
 
2946
 
 
 
3153
           
2947
3154
 
2948
3155
            /**
2949
3156
             * getter for memorySizeMax.
2953
3160
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
2954
3161
                    const axutil_env_t *env)
2955
3162
             {
2956
 
 
 
3163
                
2957
3164
                    AXIS2_ENV_CHECK(env, (int)0);
2958
3165
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
2959
 
 
 
3166
                  
2960
3167
 
2961
3168
                return _ncDescribeResourceResponseType->property_memorySizeMax;
2962
3169
             }
2970
3177
                    const axutil_env_t *env,
2971
3178
                    const int  arg_memorySizeMax)
2972
3179
             {
2973
 
 
 
3180
                
2974
3181
 
2975
3182
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2976
3183
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
2977
 
 
 
3184
                
2978
3185
                if(_ncDescribeResourceResponseType->is_valid_memorySizeMax &&
2979
3186
                        arg_memorySizeMax == _ncDescribeResourceResponseType->property_memorySizeMax)
2980
3187
                {
2981
 
 
2982
 
                    return AXIS2_SUCCESS;
 
3188
                    
 
3189
                    return AXIS2_SUCCESS; 
2983
3190
                }
2984
3191
 
2985
3192
                adb_ncDescribeResourceResponseType_reset_memorySizeMax(_ncDescribeResourceResponseType, env);
2986
3193
 
2987
3194
                _ncDescribeResourceResponseType->property_memorySizeMax = arg_memorySizeMax;
2988
3195
                        _ncDescribeResourceResponseType->is_valid_memorySizeMax = AXIS2_TRUE;
2989
 
 
 
3196
                    
2990
3197
                return AXIS2_SUCCESS;
2991
3198
             }
2992
3199
 
2993
 
 
 
3200
             
2994
3201
 
2995
3202
           /**
2996
3203
            * resetter for memorySizeMax
3006
3213
 
3007
3214
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3008
3215
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3009
 
 
3010
 
 
3011
 
               _ncDescribeResourceResponseType->is_valid_memorySizeMax = AXIS2_FALSE;
 
3216
               
 
3217
 
 
3218
               _ncDescribeResourceResponseType->is_valid_memorySizeMax = AXIS2_FALSE; 
3012
3219
               return AXIS2_SUCCESS;
3013
3220
           }
3014
3221
 
3022
3229
           {
3023
3230
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3024
3231
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3025
 
 
 
3232
               
3026
3233
               return !_ncDescribeResourceResponseType->is_valid_memorySizeMax;
3027
3234
           }
3028
3235
 
3037
3244
               return adb_ncDescribeResourceResponseType_reset_memorySizeMax(_ncDescribeResourceResponseType, env);
3038
3245
           }
3039
3246
 
3040
 
 
 
3247
           
3041
3248
 
3042
3249
            /**
3043
3250
             * getter for memorySizeAvailable.
3047
3254
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3048
3255
                    const axutil_env_t *env)
3049
3256
             {
3050
 
 
 
3257
                
3051
3258
                    AXIS2_ENV_CHECK(env, (int)0);
3052
3259
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3053
 
 
 
3260
                  
3054
3261
 
3055
3262
                return _ncDescribeResourceResponseType->property_memorySizeAvailable;
3056
3263
             }
3064
3271
                    const axutil_env_t *env,
3065
3272
                    const int  arg_memorySizeAvailable)
3066
3273
             {
3067
 
 
 
3274
                
3068
3275
 
3069
3276
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3070
3277
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3071
 
 
 
3278
                
3072
3279
                if(_ncDescribeResourceResponseType->is_valid_memorySizeAvailable &&
3073
3280
                        arg_memorySizeAvailable == _ncDescribeResourceResponseType->property_memorySizeAvailable)
3074
3281
                {
3075
 
 
3076
 
                    return AXIS2_SUCCESS;
 
3282
                    
 
3283
                    return AXIS2_SUCCESS; 
3077
3284
                }
3078
3285
 
3079
3286
                adb_ncDescribeResourceResponseType_reset_memorySizeAvailable(_ncDescribeResourceResponseType, env);
3080
3287
 
3081
3288
                _ncDescribeResourceResponseType->property_memorySizeAvailable = arg_memorySizeAvailable;
3082
3289
                        _ncDescribeResourceResponseType->is_valid_memorySizeAvailable = AXIS2_TRUE;
3083
 
 
 
3290
                    
3084
3291
                return AXIS2_SUCCESS;
3085
3292
             }
3086
3293
 
3087
 
 
 
3294
             
3088
3295
 
3089
3296
           /**
3090
3297
            * resetter for memorySizeAvailable
3100
3307
 
3101
3308
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3102
3309
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3103
 
 
3104
 
 
3105
 
               _ncDescribeResourceResponseType->is_valid_memorySizeAvailable = AXIS2_FALSE;
 
3310
               
 
3311
 
 
3312
               _ncDescribeResourceResponseType->is_valid_memorySizeAvailable = AXIS2_FALSE; 
3106
3313
               return AXIS2_SUCCESS;
3107
3314
           }
3108
3315
 
3116
3323
           {
3117
3324
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3118
3325
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3119
 
 
 
3326
               
3120
3327
               return !_ncDescribeResourceResponseType->is_valid_memorySizeAvailable;
3121
3328
           }
3122
3329
 
3131
3338
               return adb_ncDescribeResourceResponseType_reset_memorySizeAvailable(_ncDescribeResourceResponseType, env);
3132
3339
           }
3133
3340
 
3134
 
 
 
3341
           
3135
3342
 
3136
3343
            /**
3137
3344
             * getter for diskSizeMax.
3141
3348
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3142
3349
                    const axutil_env_t *env)
3143
3350
             {
3144
 
 
 
3351
                
3145
3352
                    AXIS2_ENV_CHECK(env, (int)0);
3146
3353
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3147
 
 
 
3354
                  
3148
3355
 
3149
3356
                return _ncDescribeResourceResponseType->property_diskSizeMax;
3150
3357
             }
3158
3365
                    const axutil_env_t *env,
3159
3366
                    const int  arg_diskSizeMax)
3160
3367
             {
3161
 
 
 
3368
                
3162
3369
 
3163
3370
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3164
3371
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3165
 
 
 
3372
                
3166
3373
                if(_ncDescribeResourceResponseType->is_valid_diskSizeMax &&
3167
3374
                        arg_diskSizeMax == _ncDescribeResourceResponseType->property_diskSizeMax)
3168
3375
                {
3169
 
 
3170
 
                    return AXIS2_SUCCESS;
 
3376
                    
 
3377
                    return AXIS2_SUCCESS; 
3171
3378
                }
3172
3379
 
3173
3380
                adb_ncDescribeResourceResponseType_reset_diskSizeMax(_ncDescribeResourceResponseType, env);
3174
3381
 
3175
3382
                _ncDescribeResourceResponseType->property_diskSizeMax = arg_diskSizeMax;
3176
3383
                        _ncDescribeResourceResponseType->is_valid_diskSizeMax = AXIS2_TRUE;
3177
 
 
 
3384
                    
3178
3385
                return AXIS2_SUCCESS;
3179
3386
             }
3180
3387
 
3181
 
 
 
3388
             
3182
3389
 
3183
3390
           /**
3184
3391
            * resetter for diskSizeMax
3194
3401
 
3195
3402
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3196
3403
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3197
 
 
3198
 
 
3199
 
               _ncDescribeResourceResponseType->is_valid_diskSizeMax = AXIS2_FALSE;
 
3404
               
 
3405
 
 
3406
               _ncDescribeResourceResponseType->is_valid_diskSizeMax = AXIS2_FALSE; 
3200
3407
               return AXIS2_SUCCESS;
3201
3408
           }
3202
3409
 
3210
3417
           {
3211
3418
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3212
3419
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3213
 
 
 
3420
               
3214
3421
               return !_ncDescribeResourceResponseType->is_valid_diskSizeMax;
3215
3422
           }
3216
3423
 
3225
3432
               return adb_ncDescribeResourceResponseType_reset_diskSizeMax(_ncDescribeResourceResponseType, env);
3226
3433
           }
3227
3434
 
3228
 
 
 
3435
           
3229
3436
 
3230
3437
            /**
3231
3438
             * getter for diskSizeAvailable.
3235
3442
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3236
3443
                    const axutil_env_t *env)
3237
3444
             {
3238
 
 
 
3445
                
3239
3446
                    AXIS2_ENV_CHECK(env, (int)0);
3240
3447
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3241
 
 
 
3448
                  
3242
3449
 
3243
3450
                return _ncDescribeResourceResponseType->property_diskSizeAvailable;
3244
3451
             }
3252
3459
                    const axutil_env_t *env,
3253
3460
                    const int  arg_diskSizeAvailable)
3254
3461
             {
3255
 
 
 
3462
                
3256
3463
 
3257
3464
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3258
3465
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3259
 
 
 
3466
                
3260
3467
                if(_ncDescribeResourceResponseType->is_valid_diskSizeAvailable &&
3261
3468
                        arg_diskSizeAvailable == _ncDescribeResourceResponseType->property_diskSizeAvailable)
3262
3469
                {
3263
 
 
3264
 
                    return AXIS2_SUCCESS;
 
3470
                    
 
3471
                    return AXIS2_SUCCESS; 
3265
3472
                }
3266
3473
 
3267
3474
                adb_ncDescribeResourceResponseType_reset_diskSizeAvailable(_ncDescribeResourceResponseType, env);
3268
3475
 
3269
3476
                _ncDescribeResourceResponseType->property_diskSizeAvailable = arg_diskSizeAvailable;
3270
3477
                        _ncDescribeResourceResponseType->is_valid_diskSizeAvailable = AXIS2_TRUE;
3271
 
 
 
3478
                    
3272
3479
                return AXIS2_SUCCESS;
3273
3480
             }
3274
3481
 
3275
 
 
 
3482
             
3276
3483
 
3277
3484
           /**
3278
3485
            * resetter for diskSizeAvailable
3288
3495
 
3289
3496
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3290
3497
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3291
 
 
3292
 
 
3293
 
               _ncDescribeResourceResponseType->is_valid_diskSizeAvailable = AXIS2_FALSE;
 
3498
               
 
3499
 
 
3500
               _ncDescribeResourceResponseType->is_valid_diskSizeAvailable = AXIS2_FALSE; 
3294
3501
               return AXIS2_SUCCESS;
3295
3502
           }
3296
3503
 
3304
3511
           {
3305
3512
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3306
3513
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3307
 
 
 
3514
               
3308
3515
               return !_ncDescribeResourceResponseType->is_valid_diskSizeAvailable;
3309
3516
           }
3310
3517
 
3319
3526
               return adb_ncDescribeResourceResponseType_reset_diskSizeAvailable(_ncDescribeResourceResponseType, env);
3320
3527
           }
3321
3528
 
3322
 
 
 
3529
           
3323
3530
 
3324
3531
            /**
3325
3532
             * getter for numberOfCoresMax.
3329
3536
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3330
3537
                    const axutil_env_t *env)
3331
3538
             {
3332
 
 
 
3539
                
3333
3540
                    AXIS2_ENV_CHECK(env, (int)0);
3334
3541
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3335
 
 
 
3542
                  
3336
3543
 
3337
3544
                return _ncDescribeResourceResponseType->property_numberOfCoresMax;
3338
3545
             }
3346
3553
                    const axutil_env_t *env,
3347
3554
                    const int  arg_numberOfCoresMax)
3348
3555
             {
3349
 
 
 
3556
                
3350
3557
 
3351
3558
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3352
3559
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3353
 
 
 
3560
                
3354
3561
                if(_ncDescribeResourceResponseType->is_valid_numberOfCoresMax &&
3355
3562
                        arg_numberOfCoresMax == _ncDescribeResourceResponseType->property_numberOfCoresMax)
3356
3563
                {
3357
 
 
3358
 
                    return AXIS2_SUCCESS;
 
3564
                    
 
3565
                    return AXIS2_SUCCESS; 
3359
3566
                }
3360
3567
 
3361
3568
                adb_ncDescribeResourceResponseType_reset_numberOfCoresMax(_ncDescribeResourceResponseType, env);
3362
3569
 
3363
3570
                _ncDescribeResourceResponseType->property_numberOfCoresMax = arg_numberOfCoresMax;
3364
3571
                        _ncDescribeResourceResponseType->is_valid_numberOfCoresMax = AXIS2_TRUE;
3365
 
 
 
3572
                    
3366
3573
                return AXIS2_SUCCESS;
3367
3574
             }
3368
3575
 
3369
 
 
 
3576
             
3370
3577
 
3371
3578
           /**
3372
3579
            * resetter for numberOfCoresMax
3382
3589
 
3383
3590
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3384
3591
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3385
 
 
3386
 
 
3387
 
               _ncDescribeResourceResponseType->is_valid_numberOfCoresMax = AXIS2_FALSE;
 
3592
               
 
3593
 
 
3594
               _ncDescribeResourceResponseType->is_valid_numberOfCoresMax = AXIS2_FALSE; 
3388
3595
               return AXIS2_SUCCESS;
3389
3596
           }
3390
3597
 
3398
3605
           {
3399
3606
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3400
3607
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3401
 
 
 
3608
               
3402
3609
               return !_ncDescribeResourceResponseType->is_valid_numberOfCoresMax;
3403
3610
           }
3404
3611
 
3413
3620
               return adb_ncDescribeResourceResponseType_reset_numberOfCoresMax(_ncDescribeResourceResponseType, env);
3414
3621
           }
3415
3622
 
3416
 
 
 
3623
           
3417
3624
 
3418
3625
            /**
3419
3626
             * getter for numberOfCoresAvailable.
3423
3630
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3424
3631
                    const axutil_env_t *env)
3425
3632
             {
3426
 
 
 
3633
                
3427
3634
                    AXIS2_ENV_CHECK(env, (int)0);
3428
3635
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, (int)0);
3429
 
 
 
3636
                  
3430
3637
 
3431
3638
                return _ncDescribeResourceResponseType->property_numberOfCoresAvailable;
3432
3639
             }
3440
3647
                    const axutil_env_t *env,
3441
3648
                    const int  arg_numberOfCoresAvailable)
3442
3649
             {
3443
 
 
 
3650
                
3444
3651
 
3445
3652
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3446
3653
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3447
 
 
 
3654
                
3448
3655
                if(_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable &&
3449
3656
                        arg_numberOfCoresAvailable == _ncDescribeResourceResponseType->property_numberOfCoresAvailable)
3450
3657
                {
3451
 
 
3452
 
                    return AXIS2_SUCCESS;
 
3658
                    
 
3659
                    return AXIS2_SUCCESS; 
3453
3660
                }
3454
3661
 
3455
3662
                adb_ncDescribeResourceResponseType_reset_numberOfCoresAvailable(_ncDescribeResourceResponseType, env);
3456
3663
 
3457
3664
                _ncDescribeResourceResponseType->property_numberOfCoresAvailable = arg_numberOfCoresAvailable;
3458
3665
                        _ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable = AXIS2_TRUE;
3459
 
 
 
3666
                    
3460
3667
                return AXIS2_SUCCESS;
3461
3668
             }
3462
3669
 
3463
 
 
 
3670
             
3464
3671
 
3465
3672
           /**
3466
3673
            * resetter for numberOfCoresAvailable
3476
3683
 
3477
3684
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3478
3685
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3479
 
 
3480
 
 
3481
 
               _ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable = AXIS2_FALSE;
 
3686
               
 
3687
 
 
3688
               _ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable = AXIS2_FALSE; 
3482
3689
               return AXIS2_SUCCESS;
3483
3690
           }
3484
3691
 
3492
3699
           {
3493
3700
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3494
3701
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3495
 
 
 
3702
               
3496
3703
               return !_ncDescribeResourceResponseType->is_valid_numberOfCoresAvailable;
3497
3704
           }
3498
3705
 
3507
3714
               return adb_ncDescribeResourceResponseType_reset_numberOfCoresAvailable(_ncDescribeResourceResponseType, env);
3508
3715
           }
3509
3716
 
3510
 
 
 
3717
           
3511
3718
 
3512
3719
            /**
3513
3720
             * getter for publicSubnets.
3517
3724
                    adb_ncDescribeResourceResponseType_t* _ncDescribeResourceResponseType,
3518
3725
                    const axutil_env_t *env)
3519
3726
             {
3520
 
 
 
3727
                
3521
3728
                    AXIS2_ENV_CHECK(env, NULL);
3522
3729
                    AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, NULL);
3523
 
 
 
3730
                  
3524
3731
 
3525
3732
                return _ncDescribeResourceResponseType->property_publicSubnets;
3526
3733
             }
3534
3741
                    const axutil_env_t *env,
3535
3742
                    const axis2_char_t*  arg_publicSubnets)
3536
3743
             {
3537
 
 
 
3744
                
3538
3745
 
3539
3746
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3540
3747
                AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3541
 
 
 
3748
                
3542
3749
                if(_ncDescribeResourceResponseType->is_valid_publicSubnets &&
3543
3750
                        arg_publicSubnets == _ncDescribeResourceResponseType->property_publicSubnets)
3544
3751
                {
3545
 
 
3546
 
                    return AXIS2_SUCCESS;
 
3752
                    
 
3753
                    return AXIS2_SUCCESS; 
3547
3754
                }
3548
3755
 
3549
 
 
 
3756
                
3550
3757
                  if(NULL == arg_publicSubnets)
3551
3758
                  {
3552
3759
                      AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "publicSubnets is being set to NULL, but it is not a nullable element");
3554
3761
                  }
3555
3762
                adb_ncDescribeResourceResponseType_reset_publicSubnets(_ncDescribeResourceResponseType, env);
3556
3763
 
3557
 
 
 
3764
                
3558
3765
                if(NULL == arg_publicSubnets)
3559
3766
                {
3560
3767
                    /* We are already done */
3567
3774
                            return AXIS2_FAILURE;
3568
3775
                        }
3569
3776
                        _ncDescribeResourceResponseType->is_valid_publicSubnets = AXIS2_TRUE;
3570
 
 
 
3777
                    
3571
3778
                return AXIS2_SUCCESS;
3572
3779
             }
3573
3780
 
3574
 
 
 
3781
             
3575
3782
 
3576
3783
           /**
3577
3784
            * resetter for publicSubnets
3587
3794
 
3588
3795
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3589
3796
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_FAILURE);
3590
 
 
3591
 
 
3592
 
 
3593
 
 
3594
 
 
 
3797
               
 
3798
 
 
3799
               
 
3800
            
 
3801
                
3595
3802
                if(_ncDescribeResourceResponseType->property_publicSubnets != NULL)
3596
3803
                {
3597
 
 
3598
 
 
 
3804
                   
 
3805
                   
3599
3806
                        AXIS2_FREE(env-> allocator, _ncDescribeResourceResponseType->property_publicSubnets);
3600
3807
                     _ncDescribeResourceResponseType->property_publicSubnets = NULL;
3601
3808
                }
3602
 
 
3603
 
 
3604
 
 
3605
 
                _ncDescribeResourceResponseType->is_valid_publicSubnets = AXIS2_FALSE;
 
3809
            
 
3810
                
 
3811
                
 
3812
                _ncDescribeResourceResponseType->is_valid_publicSubnets = AXIS2_FALSE; 
3606
3813
               return AXIS2_SUCCESS;
3607
3814
           }
3608
3815
 
3616
3823
           {
3617
3824
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3618
3825
               AXIS2_PARAM_CHECK(env->error, _ncDescribeResourceResponseType, AXIS2_TRUE);
3619
 
 
 
3826
               
3620
3827
               return !_ncDescribeResourceResponseType->is_valid_publicSubnets;
3621
3828
           }
3622
3829
 
3631
3838
               return adb_ncDescribeResourceResponseType_reset_publicSubnets(_ncDescribeResourceResponseType, env);
3632
3839
           }
3633
3840
 
3634
 
 
 
3841
           
3635
3842