← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cluster/generated/adb_ncGetConsoleOutputType.c

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

Show diffs side-by-side

added added

removed removed

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