← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cluster/generated/adb_ncRunInstanceResponseType.c

  • Committer: Bazaar Package Importer
  • Author(s): Dave Walker (Daviey)
  • Date: 2010-07-21 17:27:10 UTC
  • mfrom: (1.1.38 upstream)
  • Revision ID: james.westby@ubuntu.com-20100721172710-7xv07dmdqgivc3t9
Tags: 2.0~bzr1211-0ubuntu1
https://launchpad.net/bugs/597330
https://launchpad.net/bugs/595421
* New major upstream version merge, 2.0 (r1211).
* debian/patches/:
  - 01-wsdl-stubs.patch, debian/wsdl.md5sums: wsdl stubs updated.
  - 02-Makefile.patch: Updated to reflect new code layout.
  - 07-local_support_euca_conf-in.patch: Updated to reflect new code layout.
  - 08-ubuntu-default-networking.patch: Refreshed.
  - 09-small-128-192MB.patch: Updated to point to new location.
  - 10-disable-iscsi.patch: Refreshed.
  - 11-state-cleanup-memleakfix.patch: Removed, fixed upstream.
  - 15-fix-default-ramdisk.patch: Updated to point to new location.
  - 16-kvm_libvirt_xml_default_use_kvm.patch: Updated to reflect changes.
  - 17-fix_walrus_OOM_errors.patch: Removed, fixed upstream.
  - 18-priv_security.patch: Updated to reflect upstream changes.
  - 20-brute-force-webui.patch: Updated to reflect upstream changes. 
  - 21-eucalyptus-1.7-with-gwt-1.6.4.patch: New patch, allows 
    eucalyptus-1.7 to be built against gwt 1.6.4. Based on patch courtesy 
    of Dmitrii Zagorodnov, upstream. (LP: #597330)
* debian/eucalyptus-java-common.links: 
  - Changed symlink for groovy, point to groovy.all.jar, making compatiable 
    with groovy versions >1.7. (LP: #595421)
  - Added ant.jar & jetty-rewrite-handler.jar as they are now required.
* debian/control
  - & debian/build-jars: Added libjavassist-java and libjetty-extra-java as 
    build dependencies.
  - Added libjetty-extra-java as a dependency of eucalyptus-java-common
* The binary resulting jar's have been renamed from eucalyptus-*-1.6.2.jar
  to eucalyptus-*-main.jar:    
  - debian/eucalyptus-cc.upstart
  - debian/eucalyptus-cloud.install
  - debian/eucalyptus-common.eucalyptus.upstart
  - debian/eucalyptus-java-common.install
  - debian/eucalyptus-network.upstart
  - debian/eucalyptus-sc.install
  - debian/eucalyptus-walrus.install
* debian/eucalyptus-java-common.install: New upstream jars that have been
  installed:
  - eucalyptus-db-hsqldb-ext-main.jar
  - eucalyptus-component-main.jar
* debian/control:
  - Updated Standards Version to 3.8.4 (no change)
  - Updated the upstream Homepage to: http://open.eucalyptus.com/
  - Changed Vcs-Bzr to reflect new location of Ubuntu hosted development branch.
  - Made the Build Dependency of groovy and the binary eucalyptus-java-common
    package depend on version >=1.7.

Show diffs side-by-side

added added

removed removed

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