← Back to branch summary

~davewalker/ubuntu/maverick/eucalyptus/maverick_1.7

« back to all changes in this revision

Viewing changes to cluster/generated/adb_ncRunInstanceResponseType.c

  • Committer: Dave Walker (Daviey)
  • Date: 2010-06-14 12:48:44 UTC
  • Revision ID: davewalker@ubuntu.com-20100614124844-ivbfj072y90e1hdi
https://launchpad.net/bugs/566793
https://launchpad.net/bugs/579942
https://launchpad.net/bugs/586134
* Switch to dpkg-source 3.0 (quilt) format
  - Extracted the following patches from our bzr branch, into flat patches.
* debian/build-jars: Replaced asm2 with asm3-all to match new groovy dependency.
* Revert: node/handlers_kvm.c: fix console bug (was only showing first 64K).
  (LP: #566793).
* clc/modules/www/src/main/java/edu/ucsb/eucalyptus/admin/server/EucalyptusWebBackendImpl.java:
  - fix user enumeration and account brute force. Courtesy of Chris Cheney. (LP: #579942)
* debian/eucalyptus-sc.upstart: Bump maximum number of loop devices for SC to 512. (LP: #586134)

Show diffs side-by-side

added added

removed removed

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