← Back to branch summary

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

« back to all changes in this revision

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