← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gatherlog/generated/adb_getLogsResponseType.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:
gatherlog/generated/adb_getLogsResponseType.c
8
8
         */
9
9
 
10
10
        #include "adb_getLogsResponseType.h"
11
 
 
 
11
        
12
12
                /*
13
13
                 * This type was generated from the piece of schema that had
14
14
                 * name = getLogsResponseType
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_getLogsResponseType
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_char_t* property_statusMessage;
36
36
 
37
 
 
 
37
                
38
38
                axis2_bool_t is_valid_statusMessage;
39
39
 
40
40
 
41
41
            axis2_bool_t property_return;
42
42
 
43
 
 
 
43
                
44
44
                axis2_bool_t is_valid_return;
45
45
 
46
46
 
47
47
            axis2_char_t* property_serviceTag;
48
48
 
49
 
 
 
49
                
50
50
                axis2_bool_t is_valid_serviceTag;
51
51
 
52
52
 
53
53
            axis2_char_t* property_CCLog;
54
54
 
55
 
 
 
55
                
56
56
                axis2_bool_t is_valid_CCLog;
57
57
 
58
58
 
59
59
            axis2_char_t* property_NCLog;
60
60
 
61
 
 
 
61
                
62
62
                axis2_bool_t is_valid_NCLog;
63
63
 
64
64
 
65
65
            axis2_char_t* property_httpdLog;
66
66
 
67
 
 
 
67
                
68
68
                axis2_bool_t is_valid_httpdLog;
69
69
 
70
70
 
71
71
            axis2_char_t* property_axis2Log;
72
72
 
73
 
 
 
73
                
74
74
                axis2_bool_t is_valid_axis2Log;
75
75
 
76
76
 
77
 
 
 
77
            
78
78
        };
79
79
 
80
80
 
81
81
       /************************* Private Function prototypes ********************************/
82
 
 
 
82
        
83
83
 
84
84
                axis2_status_t AXIS2_CALL
85
85
                adb_getLogsResponseType_set_correlationId_nil(
86
86
                        adb_getLogsResponseType_t* _getLogsResponseType,
87
87
                        const axutil_env_t *env);
88
 
 
 
88
            
89
89
 
90
90
                axis2_status_t AXIS2_CALL
91
91
                adb_getLogsResponseType_set_userId_nil(
92
92
                        adb_getLogsResponseType_t* _getLogsResponseType,
93
93
                        const axutil_env_t *env);
94
 
 
 
94
            
95
95
 
96
96
                axis2_status_t AXIS2_CALL
97
97
                adb_getLogsResponseType_set_return_nil(
98
98
                        adb_getLogsResponseType_t* _getLogsResponseType,
99
99
                        const axutil_env_t *env);
100
 
 
 
100
            
101
101
 
102
102
                axis2_status_t AXIS2_CALL
103
103
                adb_getLogsResponseType_set_serviceTag_nil(
104
104
                        adb_getLogsResponseType_t* _getLogsResponseType,
105
105
                        const axutil_env_t *env);
106
 
 
 
106
            
107
107
 
108
108
                axis2_status_t AXIS2_CALL
109
109
                adb_getLogsResponseType_set_CCLog_nil(
110
110
                        adb_getLogsResponseType_t* _getLogsResponseType,
111
111
                        const axutil_env_t *env);
112
 
 
 
112
            
113
113
 
114
114
                axis2_status_t AXIS2_CALL
115
115
                adb_getLogsResponseType_set_NCLog_nil(
116
116
                        adb_getLogsResponseType_t* _getLogsResponseType,
117
117
                        const axutil_env_t *env);
118
 
 
 
118
            
119
119
 
120
120
                axis2_status_t AXIS2_CALL
121
121
                adb_getLogsResponseType_set_httpdLog_nil(
122
122
                        adb_getLogsResponseType_t* _getLogsResponseType,
123
123
                        const axutil_env_t *env);
124
 
 
 
124
            
125
125
 
126
126
                axis2_status_t AXIS2_CALL
127
127
                adb_getLogsResponseType_set_axis2Log_nil(
128
128
                        adb_getLogsResponseType_t* _getLogsResponseType,
129
129
                        const axutil_env_t *env);
130
 
 
 
130
            
131
131
 
132
132
 
133
133
       /************************* Function Implmentations ********************************/
136
136
            const axutil_env_t *env)
137
137
        {
138
138
            adb_getLogsResponseType_t *_getLogsResponseType = NULL;
139
 
 
 
139
            
140
140
            AXIS2_ENV_CHECK(env, NULL);
141
141
 
142
142
            _getLogsResponseType = (adb_getLogsResponseType_t *) AXIS2_MALLOC(env->
167
167
                  _getLogsResponseType->is_valid_httpdLog  = AXIS2_FALSE;
168
168
            _getLogsResponseType->property_axis2Log  = NULL;
169
169
                  _getLogsResponseType->is_valid_axis2Log  = AXIS2_FALSE;
170
 
 
 
170
            
171
171
 
172
172
            return _getLogsResponseType;
173
173
        }
177
177
                adb_getLogsResponseType_t* _getLogsResponseType,
178
178
                const axutil_env_t *env)
179
179
        {
180
 
 
 
180
            
181
181
 
182
182
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
183
183
            AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
191
191
            adb_getLogsResponseType_reset_NCLog(_getLogsResponseType, env);
192
192
            adb_getLogsResponseType_reset_httpdLog(_getLogsResponseType, env);
193
193
            adb_getLogsResponseType_reset_axis2Log(_getLogsResponseType, env);
194
 
 
 
194
            
195
195
 
196
196
            if(_getLogsResponseType)
197
197
            {
202
202
        }
203
203
 
204
204
 
205
 
 
 
205
        
206
206
 
207
207
        axis2_status_t AXIS2_CALL
208
208
        adb_getLogsResponseType_deserialize(
213
213
                axis2_bool_t dont_care_minoccurs)
214
214
        {
215
215
          axiom_node_t *parent = *dp_parent;
216
 
 
 
216
          
217
217
          axis2_status_t status = AXIS2_SUCCESS;
218
 
 
 
218
           
219
219
             axis2_char_t* text_value = NULL;
220
220
             axutil_qname_t *qname = NULL;
221
 
 
222
 
            axutil_qname_t *element_qname = NULL;
223
 
 
 
221
          
 
222
            axutil_qname_t *element_qname = NULL; 
 
223
            
224
224
               axiom_node_t *first_node = NULL;
225
225
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
226
226
               axiom_node_t *current_node = NULL;
227
227
               axiom_element_t *current_element = NULL;
228
 
 
 
228
            
229
229
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
230
230
            AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
231
231
 
232
 
 
233
 
 
 
232
            
 
233
              
234
234
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
235
235
              {
236
236
                  parent = axiom_node_get_next_sibling(parent, env);
238
238
              if (NULL == parent)
239
239
              {
240
240
                /* This should be checked before everything */
241
 
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
 
241
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
242
242
                            "Failed in building adb object for getLogsResponseType : "
243
243
                            "NULL elemenet can not be passed to deserialize");
244
244
                return AXIS2_FAILURE;
245
245
              }
246
 
 
247
 
 
 
246
              
 
247
                      
248
248
                      first_node = axiom_node_get_first_child(parent, env);
249
 
 
250
 
 
251
 
 
252
 
 
 
249
                      
 
250
                    
 
251
 
 
252
                     
253
253
                     /*
254
254
                      * building correlationId element
255
255
                      */
256
 
 
257
 
 
258
 
 
 
256
                     
 
257
                     
 
258
                     
259
259
                                   current_node = first_node;
260
260
                                   is_early_node_valid = AXIS2_FALSE;
261
 
 
262
 
 
 
261
                                   
 
262
                                   
263
263
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
264
264
                                    {
265
265
                                        current_node = axiom_node_get_next_sibling(current_node, env);
269
269
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
270
270
                                        qname = axiom_element_get_qname(current_element, env, current_node);
271
271
                                    }
272
 
 
 
272
                                   
273
273
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
274
 
 
275
 
 
276
 
                           if (
 
274
                                 
 
275
 
 
276
                           if ( 
277
277
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
278
278
                           {
279
279
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
280
280
                              {
281
281
                                is_early_node_valid = AXIS2_TRUE;
282
282
                              }
283
 
 
284
 
 
 
283
                              
 
284
                                 
285
285
                                      text_value = axiom_element_get_text(current_element, env, current_node);
286
286
                                      if(text_value != NULL)
287
287
                                      {
288
288
                                            status = adb_getLogsResponseType_set_correlationId(_getLogsResponseType, env,
289
289
                                                               text_value);
290
290
                                      }
291
 
 
 
291
                                      
292
292
                                      else
293
293
                                      {
294
294
                                            /*
295
295
                                             * axis2_qname_t *qname = NULL;
296
296
                                             * axiom_attribute_t *the_attri = NULL;
297
 
                                             *
 
297
                                             * 
298
298
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
299
299
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
300
300
                                             */
312
312
                                                 axutil_hash_index_t *hi;
313
313
                                                 void *val;
314
314
                                                 const void *key;
315
 
 
316
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
315
                                        
 
316
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
317
317
                                                 {
318
318
                                                     axutil_hash_this(hi, &key, NULL, &val);
319
 
 
 
319
                                                     
320
320
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
321
321
                                                     {
322
322
                                                         the_attri = (axiom_attribute_t*)val;
347
347
                                                                   "");
348
348
                                            }
349
349
                                      }
350
 
 
 
350
                                      
351
351
                                 if(AXIS2_FAILURE ==  status)
352
352
                                 {
353
353
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
358
358
                                     return AXIS2_FAILURE;
359
359
                                 }
360
360
                              }
361
 
 
 
361
                           
362
362
                  if(element_qname)
363
363
                  {
364
364
                     axutil_qname_free(element_qname, env);
365
365
                     element_qname = NULL;
366
366
                  }
367
 
 
368
 
 
369
 
 
 
367
                 
 
368
 
 
369
                     
370
370
                     /*
371
371
                      * building userId element
372
372
                      */
373
 
 
374
 
 
375
 
 
 
373
                     
 
374
                     
 
375
                     
376
376
                                    /*
377
377
                                     * because elements are ordered this works fine
378
378
                                     */
379
 
 
380
 
 
 
379
                                  
 
380
                                   
381
381
                                   if(current_node != NULL && is_early_node_valid)
382
382
                                   {
383
383
                                       current_node = axiom_node_get_next_sibling(current_node, env);
384
 
 
385
 
 
 
384
                                       
 
385
                                       
386
386
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
387
387
                                        {
388
388
                                            current_node = axiom_node_get_next_sibling(current_node, env);
392
392
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
393
393
                                            qname = axiom_element_get_qname(current_element, env, current_node);
394
394
                                        }
395
 
 
 
395
                                       
396
396
                                   }
397
397
                                   is_early_node_valid = AXIS2_FALSE;
398
 
 
 
398
                                 
399
399
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
400
 
 
401
 
 
402
 
                           if (
 
400
                                 
 
401
 
 
402
                           if ( 
403
403
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
404
404
                           {
405
405
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
406
406
                              {
407
407
                                is_early_node_valid = AXIS2_TRUE;
408
408
                              }
409
 
 
410
 
 
 
409
                              
 
410
                                 
411
411
                                      text_value = axiom_element_get_text(current_element, env, current_node);
412
412
                                      if(text_value != NULL)
413
413
                                      {
414
414
                                            status = adb_getLogsResponseType_set_userId(_getLogsResponseType, env,
415
415
                                                               text_value);
416
416
                                      }
417
 
 
 
417
                                      
418
418
                                      else
419
419
                                      {
420
420
                                            /*
421
421
                                             * axis2_qname_t *qname = NULL;
422
422
                                             * axiom_attribute_t *the_attri = NULL;
423
 
                                             *
 
423
                                             * 
424
424
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
425
425
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
426
426
                                             */
438
438
                                                 axutil_hash_index_t *hi;
439
439
                                                 void *val;
440
440
                                                 const void *key;
441
 
 
442
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
441
                                        
 
442
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
443
443
                                                 {
444
444
                                                     axutil_hash_this(hi, &key, NULL, &val);
445
 
 
 
445
                                                     
446
446
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
447
447
                                                     {
448
448
                                                         the_attri = (axiom_attribute_t*)val;
473
473
                                                                   "");
474
474
                                            }
475
475
                                      }
476
 
 
 
476
                                      
477
477
                                 if(AXIS2_FAILURE ==  status)
478
478
                                 {
479
479
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
484
484
                                     return AXIS2_FAILURE;
485
485
                                 }
486
486
                              }
487
 
 
 
487
                           
488
488
                  if(element_qname)
489
489
                  {
490
490
                     axutil_qname_free(element_qname, env);
491
491
                     element_qname = NULL;
492
492
                  }
493
 
 
494
 
 
495
 
 
 
493
                 
 
494
 
 
495
                     
496
496
                     /*
497
497
                      * building statusMessage element
498
498
                      */
499
 
 
500
 
 
501
 
 
 
499
                     
 
500
                     
 
501
                     
502
502
                                    /*
503
503
                                     * because elements are ordered this works fine
504
504
                                     */
505
 
 
506
 
 
 
505
                                  
 
506
                                   
507
507
                                   if(current_node != NULL && is_early_node_valid)
508
508
                                   {
509
509
                                       current_node = axiom_node_get_next_sibling(current_node, env);
510
 
 
511
 
 
 
510
                                       
 
511
                                       
512
512
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
513
513
                                        {
514
514
                                            current_node = axiom_node_get_next_sibling(current_node, env);
518
518
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
519
519
                                            qname = axiom_element_get_qname(current_element, env, current_node);
520
520
                                        }
521
 
 
 
521
                                       
522
522
                                   }
523
523
                                   is_early_node_valid = AXIS2_FALSE;
524
 
 
 
524
                                 
525
525
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
526
 
 
527
 
 
528
 
                           if (
 
526
                                 
 
527
 
 
528
                           if ( 
529
529
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
530
530
                           {
531
531
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
532
532
                              {
533
533
                                is_early_node_valid = AXIS2_TRUE;
534
534
                              }
535
 
 
536
 
 
 
535
                              
 
536
                                 
537
537
                                      text_value = axiom_element_get_text(current_element, env, current_node);
538
538
                                      if(text_value != NULL)
539
539
                                      {
540
540
                                            status = adb_getLogsResponseType_set_statusMessage(_getLogsResponseType, env,
541
541
                                                               text_value);
542
542
                                      }
543
 
 
 
543
                                      
544
544
                                 if(AXIS2_FAILURE ==  status)
545
545
                                 {
546
546
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
551
551
                                     return AXIS2_FAILURE;
552
552
                                 }
553
553
                              }
554
 
 
 
554
                           
555
555
                  if(element_qname)
556
556
                  {
557
557
                     axutil_qname_free(element_qname, env);
558
558
                     element_qname = NULL;
559
559
                  }
560
 
 
561
 
 
562
 
 
 
560
                 
 
561
 
 
562
                     
563
563
                     /*
564
564
                      * building return element
565
565
                      */
566
 
 
567
 
 
568
 
 
 
566
                     
 
567
                     
 
568
                     
569
569
                                    /*
570
570
                                     * because elements are ordered this works fine
571
571
                                     */
572
 
 
573
 
 
 
572
                                  
 
573
                                   
574
574
                                   if(current_node != NULL && is_early_node_valid)
575
575
                                   {
576
576
                                       current_node = axiom_node_get_next_sibling(current_node, env);
577
 
 
578
 
 
 
577
                                       
 
578
                                       
579
579
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
580
580
                                        {
581
581
                                            current_node = axiom_node_get_next_sibling(current_node, env);
585
585
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
586
586
                                            qname = axiom_element_get_qname(current_element, env, current_node);
587
587
                                        }
588
 
 
 
588
                                       
589
589
                                   }
590
590
                                   is_early_node_valid = AXIS2_FALSE;
591
 
 
 
591
                                 
592
592
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
593
 
 
594
 
 
595
 
                           if (
 
593
                                 
 
594
 
 
595
                           if ( 
596
596
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
597
597
                           {
598
598
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
599
599
                              {
600
600
                                is_early_node_valid = AXIS2_TRUE;
601
601
                              }
602
 
 
603
 
 
 
602
                              
 
603
                                 
604
604
                                      text_value = axiom_element_get_text(current_element, env, current_node);
605
605
                                      if(text_value != NULL)
606
606
                                      {
615
615
                                                                      AXIS2_FALSE);
616
616
                                            }
617
617
                                      }
618
 
 
 
618
                                      
619
619
                                      else
620
620
                                      {
621
621
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
622
622
                                          status = AXIS2_FAILURE;
623
623
                                      }
624
 
 
 
624
                                      
625
625
                                 if(AXIS2_FAILURE ==  status)
626
626
                                 {
627
627
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
632
632
                                     return AXIS2_FAILURE;
633
633
                                 }
634
634
                              }
635
 
 
 
635
                           
636
636
                  if(element_qname)
637
637
                  {
638
638
                     axutil_qname_free(element_qname, env);
639
639
                     element_qname = NULL;
640
640
                  }
641
 
 
642
 
 
643
 
 
 
641
                 
 
642
 
 
643
                     
644
644
                     /*
645
645
                      * building serviceTag element
646
646
                      */
647
 
 
648
 
 
649
 
 
 
647
                     
 
648
                     
 
649
                     
650
650
                                    /*
651
651
                                     * because elements are ordered this works fine
652
652
                                     */
653
 
 
654
 
 
 
653
                                  
 
654
                                   
655
655
                                   if(current_node != NULL && is_early_node_valid)
656
656
                                   {
657
657
                                       current_node = axiom_node_get_next_sibling(current_node, env);
658
 
 
659
 
 
 
658
                                       
 
659
                                       
660
660
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
661
661
                                        {
662
662
                                            current_node = axiom_node_get_next_sibling(current_node, env);
666
666
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
667
667
                                            qname = axiom_element_get_qname(current_element, env, current_node);
668
668
                                        }
669
 
 
 
669
                                       
670
670
                                   }
671
671
                                   is_early_node_valid = AXIS2_FALSE;
672
 
 
 
672
                                 
673
673
                                 element_qname = axutil_qname_create(env, "serviceTag", "http://eucalyptus.ucsb.edu/", NULL);
674
 
 
675
 
 
676
 
                           if (
 
674
                                 
 
675
 
 
676
                           if ( 
677
677
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
678
678
                           {
679
679
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
680
680
                              {
681
681
                                is_early_node_valid = AXIS2_TRUE;
682
682
                              }
683
 
 
684
 
 
 
683
                              
 
684
                                 
685
685
                                      text_value = axiom_element_get_text(current_element, env, current_node);
686
686
                                      if(text_value != NULL)
687
687
                                      {
688
688
                                            status = adb_getLogsResponseType_set_serviceTag(_getLogsResponseType, env,
689
689
                                                               text_value);
690
690
                                      }
691
 
 
 
691
                                      
692
692
                                      else
693
693
                                      {
694
694
                                            /*
695
695
                                             * axis2_qname_t *qname = NULL;
696
696
                                             * axiom_attribute_t *the_attri = NULL;
697
 
                                             *
 
697
                                             * 
698
698
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
699
699
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
700
700
                                             */
712
712
                                                 axutil_hash_index_t *hi;
713
713
                                                 void *val;
714
714
                                                 const void *key;
715
 
 
716
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
715
                                        
 
716
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
717
717
                                                 {
718
718
                                                     axutil_hash_this(hi, &key, NULL, &val);
719
 
 
 
719
                                                     
720
720
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
721
721
                                                     {
722
722
                                                         the_attri = (axiom_attribute_t*)val;
747
747
                                                                   "");
748
748
                                            }
749
749
                                      }
750
 
 
 
750
                                      
751
751
                                 if(AXIS2_FAILURE ==  status)
752
752
                                 {
753
753
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for serviceTag ");
758
758
                                     return AXIS2_FAILURE;
759
759
                                 }
760
760
                              }
761
 
 
 
761
                           
762
762
                  if(element_qname)
763
763
                  {
764
764
                     axutil_qname_free(element_qname, env);
765
765
                     element_qname = NULL;
766
766
                  }
767
 
 
768
 
 
769
 
 
 
767
                 
 
768
 
 
769
                     
770
770
                     /*
771
771
                      * building CCLog element
772
772
                      */
773
 
 
774
 
 
775
 
 
 
773
                     
 
774
                     
 
775
                     
776
776
                                    /*
777
777
                                     * because elements are ordered this works fine
778
778
                                     */
779
 
 
780
 
 
 
779
                                  
 
780
                                   
781
781
                                   if(current_node != NULL && is_early_node_valid)
782
782
                                   {
783
783
                                       current_node = axiom_node_get_next_sibling(current_node, env);
784
 
 
785
 
 
 
784
                                       
 
785
                                       
786
786
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
787
787
                                        {
788
788
                                            current_node = axiom_node_get_next_sibling(current_node, env);
792
792
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
793
793
                                            qname = axiom_element_get_qname(current_element, env, current_node);
794
794
                                        }
795
 
 
 
795
                                       
796
796
                                   }
797
797
                                   is_early_node_valid = AXIS2_FALSE;
798
 
 
 
798
                                 
799
799
                                 element_qname = axutil_qname_create(env, "CCLog", "http://eucalyptus.ucsb.edu/", NULL);
800
 
 
801
 
 
802
 
                           if (
 
800
                                 
 
801
 
 
802
                           if ( 
803
803
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
804
804
                           {
805
805
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
806
806
                              {
807
807
                                is_early_node_valid = AXIS2_TRUE;
808
808
                              }
809
 
 
810
 
 
 
809
                              
 
810
                                 
811
811
                                      text_value = axiom_element_get_text(current_element, env, current_node);
812
812
                                      if(text_value != NULL)
813
813
                                      {
814
814
                                            status = adb_getLogsResponseType_set_CCLog(_getLogsResponseType, env,
815
815
                                                               text_value);
816
816
                                      }
817
 
 
 
817
                                      
818
818
                                      else
819
819
                                      {
820
820
                                            /*
821
821
                                             * axis2_qname_t *qname = NULL;
822
822
                                             * axiom_attribute_t *the_attri = NULL;
823
 
                                             *
 
823
                                             * 
824
824
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
825
825
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
826
826
                                             */
838
838
                                                 axutil_hash_index_t *hi;
839
839
                                                 void *val;
840
840
                                                 const void *key;
841
 
 
842
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
841
                                        
 
842
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
843
843
                                                 {
844
844
                                                     axutil_hash_this(hi, &key, NULL, &val);
845
 
 
 
845
                                                     
846
846
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
847
847
                                                     {
848
848
                                                         the_attri = (axiom_attribute_t*)val;
873
873
                                                                   "");
874
874
                                            }
875
875
                                      }
876
 
 
 
876
                                      
877
877
                                 if(AXIS2_FAILURE ==  status)
878
878
                                 {
879
879
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for CCLog ");
884
884
                                     return AXIS2_FAILURE;
885
885
                                 }
886
886
                              }
887
 
 
 
887
                           
888
888
                  if(element_qname)
889
889
                  {
890
890
                     axutil_qname_free(element_qname, env);
891
891
                     element_qname = NULL;
892
892
                  }
893
 
 
894
 
 
895
 
 
 
893
                 
 
894
 
 
895
                     
896
896
                     /*
897
897
                      * building NCLog element
898
898
                      */
899
 
 
900
 
 
901
 
 
 
899
                     
 
900
                     
 
901
                     
902
902
                                    /*
903
903
                                     * because elements are ordered this works fine
904
904
                                     */
905
 
 
906
 
 
 
905
                                  
 
906
                                   
907
907
                                   if(current_node != NULL && is_early_node_valid)
908
908
                                   {
909
909
                                       current_node = axiom_node_get_next_sibling(current_node, env);
910
 
 
911
 
 
 
910
                                       
 
911
                                       
912
912
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
913
913
                                        {
914
914
                                            current_node = axiom_node_get_next_sibling(current_node, env);
918
918
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
919
919
                                            qname = axiom_element_get_qname(current_element, env, current_node);
920
920
                                        }
921
 
 
 
921
                                       
922
922
                                   }
923
923
                                   is_early_node_valid = AXIS2_FALSE;
924
 
 
 
924
                                 
925
925
                                 element_qname = axutil_qname_create(env, "NCLog", "http://eucalyptus.ucsb.edu/", NULL);
926
 
 
927
 
 
928
 
                           if (
 
926
                                 
 
927
 
 
928
                           if ( 
929
929
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
930
930
                           {
931
931
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
932
932
                              {
933
933
                                is_early_node_valid = AXIS2_TRUE;
934
934
                              }
935
 
 
936
 
 
 
935
                              
 
936
                                 
937
937
                                      text_value = axiom_element_get_text(current_element, env, current_node);
938
938
                                      if(text_value != NULL)
939
939
                                      {
940
940
                                            status = adb_getLogsResponseType_set_NCLog(_getLogsResponseType, env,
941
941
                                                               text_value);
942
942
                                      }
943
 
 
 
943
                                      
944
944
                                      else
945
945
                                      {
946
946
                                            /*
947
947
                                             * axis2_qname_t *qname = NULL;
948
948
                                             * axiom_attribute_t *the_attri = NULL;
949
 
                                             *
 
949
                                             * 
950
950
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
951
951
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
952
952
                                             */
964
964
                                                 axutil_hash_index_t *hi;
965
965
                                                 void *val;
966
966
                                                 const void *key;
967
 
 
968
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
967
                                        
 
968
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
969
969
                                                 {
970
970
                                                     axutil_hash_this(hi, &key, NULL, &val);
971
 
 
 
971
                                                     
972
972
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
973
973
                                                     {
974
974
                                                         the_attri = (axiom_attribute_t*)val;
999
999
                                                                   "");
1000
1000
                                            }
1001
1001
                                      }
1002
 
 
 
1002
                                      
1003
1003
                                 if(AXIS2_FAILURE ==  status)
1004
1004
                                 {
1005
1005
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for NCLog ");
1010
1010
                                     return AXIS2_FAILURE;
1011
1011
                                 }
1012
1012
                              }
1013
 
 
 
1013
                           
1014
1014
                  if(element_qname)
1015
1015
                  {
1016
1016
                     axutil_qname_free(element_qname, env);
1017
1017
                     element_qname = NULL;
1018
1018
                  }
1019
 
 
1020
 
 
1021
 
 
 
1019
                 
 
1020
 
 
1021
                     
1022
1022
                     /*
1023
1023
                      * building httpdLog element
1024
1024
                      */
1025
 
 
1026
 
 
1027
 
 
 
1025
                     
 
1026
                     
 
1027
                     
1028
1028
                                    /*
1029
1029
                                     * because elements are ordered this works fine
1030
1030
                                     */
1031
 
 
1032
 
 
 
1031
                                  
 
1032
                                   
1033
1033
                                   if(current_node != NULL && is_early_node_valid)
1034
1034
                                   {
1035
1035
                                       current_node = axiom_node_get_next_sibling(current_node, env);
1036
 
 
1037
 
 
 
1036
                                       
 
1037
                                       
1038
1038
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1039
1039
                                        {
1040
1040
                                            current_node = axiom_node_get_next_sibling(current_node, env);
1044
1044
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1045
1045
                                            qname = axiom_element_get_qname(current_element, env, current_node);
1046
1046
                                        }
1047
 
 
 
1047
                                       
1048
1048
                                   }
1049
1049
                                   is_early_node_valid = AXIS2_FALSE;
1050
 
 
 
1050
                                 
1051
1051
                                 element_qname = axutil_qname_create(env, "httpdLog", "http://eucalyptus.ucsb.edu/", NULL);
1052
 
 
1053
 
 
1054
 
                           if (
 
1052
                                 
 
1053
 
 
1054
                           if ( 
1055
1055
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
1056
1056
                           {
1057
1057
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
1058
1058
                              {
1059
1059
                                is_early_node_valid = AXIS2_TRUE;
1060
1060
                              }
1061
 
 
1062
 
 
 
1061
                              
 
1062
                                 
1063
1063
                                      text_value = axiom_element_get_text(current_element, env, current_node);
1064
1064
                                      if(text_value != NULL)
1065
1065
                                      {
1066
1066
                                            status = adb_getLogsResponseType_set_httpdLog(_getLogsResponseType, env,
1067
1067
                                                               text_value);
1068
1068
                                      }
1069
 
 
 
1069
                                      
1070
1070
                                      else
1071
1071
                                      {
1072
1072
                                            /*
1073
1073
                                             * axis2_qname_t *qname = NULL;
1074
1074
                                             * axiom_attribute_t *the_attri = NULL;
1075
 
                                             *
 
1075
                                             * 
1076
1076
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1077
1077
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
1078
1078
                                             */
1090
1090
                                                 axutil_hash_index_t *hi;
1091
1091
                                                 void *val;
1092
1092
                                                 const void *key;
1093
 
 
1094
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
1093
                                        
 
1094
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
1095
1095
                                                 {
1096
1096
                                                     axutil_hash_this(hi, &key, NULL, &val);
1097
 
 
 
1097
                                                     
1098
1098
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1099
1099
                                                     {
1100
1100
                                                         the_attri = (axiom_attribute_t*)val;
1125
1125
                                                                   "");
1126
1126
                                            }
1127
1127
                                      }
1128
 
 
 
1128
                                      
1129
1129
                                 if(AXIS2_FAILURE ==  status)
1130
1130
                                 {
1131
1131
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for httpdLog ");
1136
1136
                                     return AXIS2_FAILURE;
1137
1137
                                 }
1138
1138
                              }
1139
 
 
 
1139
                           
1140
1140
                  if(element_qname)
1141
1141
                  {
1142
1142
                     axutil_qname_free(element_qname, env);
1143
1143
                     element_qname = NULL;
1144
1144
                  }
1145
 
 
1146
 
 
1147
 
 
 
1145
                 
 
1146
 
 
1147
                     
1148
1148
                     /*
1149
1149
                      * building axis2Log element
1150
1150
                      */
1151
 
 
1152
 
 
1153
 
 
 
1151
                     
 
1152
                     
 
1153
                     
1154
1154
                                    /*
1155
1155
                                     * because elements are ordered this works fine
1156
1156
                                     */
1157
 
 
1158
 
 
 
1157
                                  
 
1158
                                   
1159
1159
                                   if(current_node != NULL && is_early_node_valid)
1160
1160
                                   {
1161
1161
                                       current_node = axiom_node_get_next_sibling(current_node, env);
1162
 
 
1163
 
 
 
1162
                                       
 
1163
                                       
1164
1164
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
1165
1165
                                        {
1166
1166
                                            current_node = axiom_node_get_next_sibling(current_node, env);
1170
1170
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
1171
1171
                                            qname = axiom_element_get_qname(current_element, env, current_node);
1172
1172
                                        }
1173
 
 
 
1173
                                       
1174
1174
                                   }
1175
1175
                                   is_early_node_valid = AXIS2_FALSE;
1176
 
 
 
1176
                                 
1177
1177
                                 element_qname = axutil_qname_create(env, "axis2Log", "http://eucalyptus.ucsb.edu/", NULL);
1178
 
 
1179
 
 
1180
 
                           if (
 
1178
                                 
 
1179
 
 
1180
                           if ( 
1181
1181
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
1182
1182
                           {
1183
1183
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
1184
1184
                              {
1185
1185
                                is_early_node_valid = AXIS2_TRUE;
1186
1186
                              }
1187
 
 
1188
 
 
 
1187
                              
 
1188
                                 
1189
1189
                                      text_value = axiom_element_get_text(current_element, env, current_node);
1190
1190
                                      if(text_value != NULL)
1191
1191
                                      {
1192
1192
                                            status = adb_getLogsResponseType_set_axis2Log(_getLogsResponseType, env,
1193
1193
                                                               text_value);
1194
1194
                                      }
1195
 
 
 
1195
                                      
1196
1196
                                      else
1197
1197
                                      {
1198
1198
                                            /*
1199
1199
                                             * axis2_qname_t *qname = NULL;
1200
1200
                                             * axiom_attribute_t *the_attri = NULL;
1201
 
                                             *
 
1201
                                             * 
1202
1202
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
1203
1203
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
1204
1204
                                             */
1216
1216
                                                 axutil_hash_index_t *hi;
1217
1217
                                                 void *val;
1218
1218
                                                 const void *key;
1219
 
 
1220
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
1219
                                        
 
1220
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
1221
1221
                                                 {
1222
1222
                                                     axutil_hash_this(hi, &key, NULL, &val);
1223
 
 
 
1223
                                                     
1224
1224
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
1225
1225
                                                     {
1226
1226
                                                         the_attri = (axiom_attribute_t*)val;
1251
1251
                                                                   "");
1252
1252
                                            }
1253
1253
                                      }
1254
 
 
 
1254
                                      
1255
1255
                                 if(AXIS2_FAILURE ==  status)
1256
1256
                                 {
1257
1257
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for axis2Log ");
1262
1262
                                     return AXIS2_FAILURE;
1263
1263
                                 }
1264
1264
                              }
1265
 
 
 
1265
                           
1266
1266
                  if(element_qname)
1267
1267
                  {
1268
1268
                     axutil_qname_free(element_qname, env);
1269
1269
                     element_qname = NULL;
1270
1270
                  }
1271
 
 
 
1271
                 
1272
1272
          return status;
1273
1273
       }
1274
1274
 
1275
1275
          axis2_bool_t AXIS2_CALL
1276
1276
          adb_getLogsResponseType_is_particle()
1277
1277
          {
1278
 
 
 
1278
            
1279
1279
                 return AXIS2_FALSE;
1280
 
 
 
1280
              
1281
1281
          }
1282
1282
 
1283
1283
 
1287
1287
                    const axutil_env_t *env, axiom_element_t *parent_element,
1288
1288
                    axutil_hash_t *namespaces, int *next_ns_index)
1289
1289
          {
1290
 
 
 
1290
            
1291
1291
                  /* Here this is an empty function, Nothing to declare */
1292
 
 
 
1292
                 
1293
1293
          }
1294
1294
 
1295
 
 
1296
 
 
 
1295
        
 
1296
        
1297
1297
        axiom_node_t* AXIS2_CALL
1298
1298
        adb_getLogsResponseType_serialize(
1299
1299
                adb_getLogsResponseType_t* _getLogsResponseType,
1300
1300
                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)
1301
1301
        {
1302
 
 
1303
 
 
 
1302
            
 
1303
            
1304
1304
             axis2_char_t *string_to_stream;
1305
 
 
1306
 
 
 
1305
            
 
1306
         
1307
1307
         axiom_node_t *current_node = NULL;
1308
1308
         int tag_closed = 0;
1309
1309
 
1310
 
 
1311
 
 
 
1310
         
 
1311
         
1312
1312
                axiom_namespace_t *ns1 = NULL;
1313
1313
 
1314
1314
                axis2_char_t *qname_uri = NULL;
1315
1315
                axis2_char_t *qname_prefix = NULL;
1316
1316
                axis2_char_t *p_prefix = NULL;
1317
1317
                axis2_bool_t ns_already_defined;
1318
 
 
 
1318
            
1319
1319
                    axis2_char_t *text_value_1;
1320
1320
                    axis2_char_t *text_value_1_temp;
1321
 
 
 
1321
                    
1322
1322
                    axis2_char_t *text_value_2;
1323
1323
                    axis2_char_t *text_value_2_temp;
1324
 
 
 
1324
                    
1325
1325
                    axis2_char_t *text_value_3;
1326
1326
                    axis2_char_t *text_value_3_temp;
1327
 
 
 
1327
                    
1328
1328
                    axis2_char_t text_value_4[64];
1329
 
 
 
1329
                    
1330
1330
                    axis2_char_t *text_value_5;
1331
1331
                    axis2_char_t *text_value_5_temp;
1332
 
 
 
1332
                    
1333
1333
                    axis2_char_t *text_value_6;
1334
1334
                    axis2_char_t *text_value_6_temp;
1335
 
 
 
1335
                    
1336
1336
                    axis2_char_t *text_value_7;
1337
1337
                    axis2_char_t *text_value_7_temp;
1338
 
 
 
1338
                    
1339
1339
                    axis2_char_t *text_value_8;
1340
1340
                    axis2_char_t *text_value_8_temp;
1341
 
 
 
1341
                    
1342
1342
                    axis2_char_t *text_value_9;
1343
1343
                    axis2_char_t *text_value_9_temp;
1344
 
 
 
1344
                    
1345
1345
               axis2_char_t *start_input_str = NULL;
1346
1346
               axis2_char_t *end_input_str = NULL;
1347
1347
               unsigned int start_input_str_len = 0;
1348
1348
               unsigned int end_input_str_len = 0;
1349
 
 
1350
 
 
 
1349
            
 
1350
            
1351
1351
               axiom_data_source_t *data_source = NULL;
1352
1352
               axutil_stream_t *stream = NULL;
1353
1353
 
1354
 
 
 
1354
            
1355
1355
 
1356
1356
            AXIS2_ENV_CHECK(env, NULL);
1357
1357
            AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
1358
 
 
1359
 
 
 
1358
            
 
1359
            
1360
1360
                    current_node = parent;
1361
1361
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
1362
1362
                    if (!data_source)
1364
1364
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
1365
1365
                    if (!stream)
1366
1366
                        return NULL;
1367
 
 
 
1367
                  
1368
1368
            if(!parent_tag_closed)
1369
1369
            {
1370
 
 
1371
 
              string_to_stream = ">";
 
1370
            
 
1371
              string_to_stream = ">"; 
1372
1372
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
1373
1373
              tag_closed = 1;
1374
 
 
 
1374
            
1375
1375
            }
1376
 
 
 
1376
            
1377
1377
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1378
1378
                       {
1379
1379
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1380
1380
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1381
1381
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1382
 
 
 
1382
                           
1383
1383
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1384
1384
                                            "http://eucalyptus.ucsb.edu/",
1385
1385
                                            p_prefix));
1386
1386
                       }
1387
 
 
 
1387
                      
1388
1388
 
1389
1389
                   if (!_getLogsResponseType->is_valid_correlationId)
1390
1390
                   {
1391
 
 
 
1391
                      
1392
1392
                           /* no need to complain for minoccurs=0 element */
1393
 
 
1394
 
 
 
1393
                            
 
1394
                          
1395
1395
                   }
1396
1396
                   else
1397
1397
                   {
1398
1398
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1399
 
                                 (4 + axutil_strlen(p_prefix) +
1400
 
                                  axutil_strlen("correlationId")));
1401
 
 
 
1399
                                 (4 + axutil_strlen(p_prefix) + 
 
1400
                                  axutil_strlen("correlationId"))); 
 
1401
                                 
1402
1402
                                 /* axutil_strlen("<:>") + 1 = 4 */
1403
1403
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1404
1404
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
1405
1405
                                  /* axutil_strlen("</:>") + 1 = 5 */
1406
 
 
1407
 
 
1408
 
 
1409
 
 
1410
 
 
1411
 
 
 
1406
                                  
 
1407
                     
 
1408
 
 
1409
                   
 
1410
                   
 
1411
                     
1412
1412
                     /*
1413
1413
                      * parsing correlationId element
1414
1414
                      */
1415
1415
 
1416
 
 
1417
 
 
 
1416
                    
 
1417
                    
1418
1418
                            sprintf(start_input_str, "<%s%scorrelationId>",
1419
1419
                                 p_prefix?p_prefix:"",
1420
1420
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1421
 
 
 
1421
                            
1422
1422
                        start_input_str_len = axutil_strlen(start_input_str);
1423
1423
                        sprintf(end_input_str, "</%s%scorrelationId>",
1424
1424
                                 p_prefix?p_prefix:"",
1425
1425
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1426
1426
                        end_input_str_len = axutil_strlen(end_input_str);
1427
 
 
 
1427
                    
1428
1428
                           text_value_1 = _getLogsResponseType->property_correlationId;
1429
 
 
 
1429
                           
1430
1430
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1431
 
 
1432
 
 
 
1431
                           
 
1432
                            
1433
1433
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1434
1434
                           if (text_value_1_temp)
1435
1435
                           {
1440
1440
                           {
1441
1441
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1442
1442
                           }
1443
 
 
 
1443
                           
1444
1444
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1445
 
 
1446
 
 
 
1445
                           
 
1446
                     
1447
1447
                     AXIS2_FREE(env->allocator,start_input_str);
1448
1448
                     AXIS2_FREE(env->allocator,end_input_str);
1449
 
                 }
1450
 
 
1451
 
 
 
1449
                 } 
 
1450
 
 
1451
                 
1452
1452
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1453
1453
                       {
1454
1454
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1455
1455
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1456
1456
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1457
 
 
 
1457
                           
1458
1458
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1459
1459
                                            "http://eucalyptus.ucsb.edu/",
1460
1460
                                            p_prefix));
1461
1461
                       }
1462
 
 
 
1462
                      
1463
1463
 
1464
1464
                   if (!_getLogsResponseType->is_valid_userId)
1465
1465
                   {
1466
 
 
 
1466
                      
1467
1467
                           /* no need to complain for minoccurs=0 element */
1468
 
 
1469
 
 
 
1468
                            
 
1469
                          
1470
1470
                   }
1471
1471
                   else
1472
1472
                   {
1473
1473
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1474
 
                                 (4 + axutil_strlen(p_prefix) +
1475
 
                                  axutil_strlen("userId")));
1476
 
 
 
1474
                                 (4 + axutil_strlen(p_prefix) + 
 
1475
                                  axutil_strlen("userId"))); 
 
1476
                                 
1477
1477
                                 /* axutil_strlen("<:>") + 1 = 4 */
1478
1478
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1479
1479
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1480
1480
                                  /* axutil_strlen("</:>") + 1 = 5 */
1481
 
 
1482
 
 
1483
 
 
1484
 
 
1485
 
 
1486
 
 
 
1481
                                  
 
1482
                     
 
1483
 
 
1484
                   
 
1485
                   
 
1486
                     
1487
1487
                     /*
1488
1488
                      * parsing userId element
1489
1489
                      */
1490
1490
 
1491
 
 
1492
 
 
 
1491
                    
 
1492
                    
1493
1493
                            sprintf(start_input_str, "<%s%suserId>",
1494
1494
                                 p_prefix?p_prefix:"",
1495
1495
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1496
 
 
 
1496
                            
1497
1497
                        start_input_str_len = axutil_strlen(start_input_str);
1498
1498
                        sprintf(end_input_str, "</%s%suserId>",
1499
1499
                                 p_prefix?p_prefix:"",
1500
1500
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1501
1501
                        end_input_str_len = axutil_strlen(end_input_str);
1502
 
 
 
1502
                    
1503
1503
                           text_value_2 = _getLogsResponseType->property_userId;
1504
 
 
 
1504
                           
1505
1505
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1506
 
 
1507
 
 
 
1506
                           
 
1507
                            
1508
1508
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1509
1509
                           if (text_value_2_temp)
1510
1510
                           {
1515
1515
                           {
1516
1516
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1517
1517
                           }
1518
 
 
 
1518
                           
1519
1519
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1520
 
 
1521
 
 
 
1520
                           
 
1521
                     
1522
1522
                     AXIS2_FREE(env->allocator,start_input_str);
1523
1523
                     AXIS2_FREE(env->allocator,end_input_str);
1524
 
                 }
1525
 
 
1526
 
 
 
1524
                 } 
 
1525
 
 
1526
                 
1527
1527
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1528
1528
                       {
1529
1529
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1530
1530
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1531
1531
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1532
 
 
 
1532
                           
1533
1533
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1534
1534
                                            "http://eucalyptus.ucsb.edu/",
1535
1535
                                            p_prefix));
1536
1536
                       }
1537
 
 
 
1537
                      
1538
1538
 
1539
1539
                   if (!_getLogsResponseType->is_valid_statusMessage)
1540
1540
                   {
1541
 
 
 
1541
                      
1542
1542
                           /* no need to complain for minoccurs=0 element */
1543
 
 
1544
 
 
 
1543
                            
 
1544
                          
1545
1545
                   }
1546
1546
                   else
1547
1547
                   {
1548
1548
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1549
 
                                 (4 + axutil_strlen(p_prefix) +
1550
 
                                  axutil_strlen("statusMessage")));
1551
 
 
 
1549
                                 (4 + axutil_strlen(p_prefix) + 
 
1550
                                  axutil_strlen("statusMessage"))); 
 
1551
                                 
1552
1552
                                 /* axutil_strlen("<:>") + 1 = 4 */
1553
1553
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1554
1554
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1555
1555
                                  /* axutil_strlen("</:>") + 1 = 5 */
1556
 
 
1557
 
 
1558
 
 
1559
 
 
1560
 
 
1561
 
 
 
1556
                                  
 
1557
                     
 
1558
 
 
1559
                   
 
1560
                   
 
1561
                     
1562
1562
                     /*
1563
1563
                      * parsing statusMessage element
1564
1564
                      */
1565
1565
 
1566
 
 
1567
 
 
 
1566
                    
 
1567
                    
1568
1568
                            sprintf(start_input_str, "<%s%sstatusMessage>",
1569
1569
                                 p_prefix?p_prefix:"",
1570
1570
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1571
 
 
 
1571
                            
1572
1572
                        start_input_str_len = axutil_strlen(start_input_str);
1573
1573
                        sprintf(end_input_str, "</%s%sstatusMessage>",
1574
1574
                                 p_prefix?p_prefix:"",
1575
1575
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1576
1576
                        end_input_str_len = axutil_strlen(end_input_str);
1577
 
 
 
1577
                    
1578
1578
                           text_value_3 = _getLogsResponseType->property_statusMessage;
1579
 
 
 
1579
                           
1580
1580
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1581
 
 
1582
 
 
 
1581
                           
 
1582
                            
1583
1583
                           text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1584
1584
                           if (text_value_3_temp)
1585
1585
                           {
1590
1590
                           {
1591
1591
                               axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1592
1592
                           }
1593
 
 
 
1593
                           
1594
1594
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1595
 
 
1596
 
 
 
1595
                           
 
1596
                     
1597
1597
                     AXIS2_FREE(env->allocator,start_input_str);
1598
1598
                     AXIS2_FREE(env->allocator,end_input_str);
1599
 
                 }
1600
 
 
1601
 
 
 
1599
                 } 
 
1600
 
 
1601
                 
1602
1602
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1603
1603
                       {
1604
1604
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1605
1605
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1606
1606
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1607
 
 
 
1607
                           
1608
1608
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1609
1609
                                            "http://eucalyptus.ucsb.edu/",
1610
1610
                                            p_prefix));
1611
1611
                       }
1612
 
 
 
1612
                      
1613
1613
 
1614
1614
                   if (!_getLogsResponseType->is_valid_return)
1615
1615
                   {
1616
 
 
 
1616
                      
1617
1617
                           /* no need to complain for minoccurs=0 element */
1618
 
 
1619
 
 
 
1618
                            
 
1619
                          
1620
1620
                   }
1621
1621
                   else
1622
1622
                   {
1623
1623
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1624
 
                                 (4 + axutil_strlen(p_prefix) +
1625
 
                                  axutil_strlen("return")));
1626
 
 
 
1624
                                 (4 + axutil_strlen(p_prefix) + 
 
1625
                                  axutil_strlen("return"))); 
 
1626
                                 
1627
1627
                                 /* axutil_strlen("<:>") + 1 = 4 */
1628
1628
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1629
1629
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1630
1630
                                  /* axutil_strlen("</:>") + 1 = 5 */
1631
 
 
1632
 
 
1633
 
 
1634
 
 
1635
 
 
1636
 
 
 
1631
                                  
 
1632
                     
 
1633
 
 
1634
                   
 
1635
                   
 
1636
                     
1637
1637
                     /*
1638
1638
                      * parsing return element
1639
1639
                      */
1640
1640
 
1641
 
 
1642
 
 
 
1641
                    
 
1642
                    
1643
1643
                            sprintf(start_input_str, "<%s%sreturn>",
1644
1644
                                 p_prefix?p_prefix:"",
1645
1645
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1646
 
 
 
1646
                            
1647
1647
                        start_input_str_len = axutil_strlen(start_input_str);
1648
1648
                        sprintf(end_input_str, "</%s%sreturn>",
1649
1649
                                 p_prefix?p_prefix:"",
1650
1650
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1651
1651
                        end_input_str_len = axutil_strlen(end_input_str);
1652
 
 
 
1652
                    
1653
1653
                           strcpy(text_value_4, (_getLogsResponseType->property_return)?"true":"false");
1654
 
 
 
1654
                           
1655
1655
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1656
 
 
 
1656
                           
1657
1657
                           axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1658
 
 
 
1658
                           
1659
1659
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1660
 
 
1661
 
 
 
1660
                           
 
1661
                     
1662
1662
                     AXIS2_FREE(env->allocator,start_input_str);
1663
1663
                     AXIS2_FREE(env->allocator,end_input_str);
1664
 
                 }
1665
 
 
1666
 
 
 
1664
                 } 
 
1665
 
 
1666
                 
1667
1667
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1668
1668
                       {
1669
1669
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1670
1670
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1671
1671
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1672
 
 
 
1672
                           
1673
1673
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1674
1674
                                            "http://eucalyptus.ucsb.edu/",
1675
1675
                                            p_prefix));
1676
1676
                       }
1677
 
 
 
1677
                      
1678
1678
 
1679
1679
                   if (!_getLogsResponseType->is_valid_serviceTag)
1680
1680
                   {
1681
 
 
 
1681
                      
1682
1682
                           /* no need to complain for minoccurs=0 element */
1683
 
 
1684
 
 
 
1683
                            
 
1684
                          
1685
1685
                   }
1686
1686
                   else
1687
1687
                   {
1688
1688
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1689
 
                                 (4 + axutil_strlen(p_prefix) +
1690
 
                                  axutil_strlen("serviceTag")));
1691
 
 
 
1689
                                 (4 + axutil_strlen(p_prefix) + 
 
1690
                                  axutil_strlen("serviceTag"))); 
 
1691
                                 
1692
1692
                                 /* axutil_strlen("<:>") + 1 = 4 */
1693
1693
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1694
1694
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("serviceTag")));
1695
1695
                                  /* axutil_strlen("</:>") + 1 = 5 */
1696
 
 
1697
 
 
1698
 
 
1699
 
 
1700
 
 
1701
 
 
 
1696
                                  
 
1697
                     
 
1698
 
 
1699
                   
 
1700
                   
 
1701
                     
1702
1702
                     /*
1703
1703
                      * parsing serviceTag element
1704
1704
                      */
1705
1705
 
1706
 
 
1707
 
 
 
1706
                    
 
1707
                    
1708
1708
                            sprintf(start_input_str, "<%s%sserviceTag>",
1709
1709
                                 p_prefix?p_prefix:"",
1710
1710
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1711
 
 
 
1711
                            
1712
1712
                        start_input_str_len = axutil_strlen(start_input_str);
1713
1713
                        sprintf(end_input_str, "</%s%sserviceTag>",
1714
1714
                                 p_prefix?p_prefix:"",
1715
1715
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1716
1716
                        end_input_str_len = axutil_strlen(end_input_str);
1717
 
 
 
1717
                    
1718
1718
                           text_value_5 = _getLogsResponseType->property_serviceTag;
1719
 
 
 
1719
                           
1720
1720
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1721
 
 
1722
 
 
 
1721
                           
 
1722
                            
1723
1723
                           text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1724
1724
                           if (text_value_5_temp)
1725
1725
                           {
1730
1730
                           {
1731
1731
                               axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1732
1732
                           }
1733
 
 
 
1733
                           
1734
1734
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1735
 
 
1736
 
 
 
1735
                           
 
1736
                     
1737
1737
                     AXIS2_FREE(env->allocator,start_input_str);
1738
1738
                     AXIS2_FREE(env->allocator,end_input_str);
1739
 
                 }
1740
 
 
1741
 
 
 
1739
                 } 
 
1740
 
 
1741
                 
1742
1742
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1743
1743
                       {
1744
1744
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1745
1745
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1746
1746
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1747
 
 
 
1747
                           
1748
1748
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1749
1749
                                            "http://eucalyptus.ucsb.edu/",
1750
1750
                                            p_prefix));
1751
1751
                       }
1752
 
 
 
1752
                      
1753
1753
 
1754
1754
                   if (!_getLogsResponseType->is_valid_CCLog)
1755
1755
                   {
1756
 
 
 
1756
                      
1757
1757
                           /* no need to complain for minoccurs=0 element */
1758
 
 
1759
 
 
 
1758
                            
 
1759
                          
1760
1760
                   }
1761
1761
                   else
1762
1762
                   {
1763
1763
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1764
 
                                 (4 + axutil_strlen(p_prefix) +
1765
 
                                  axutil_strlen("CCLog")));
1766
 
 
 
1764
                                 (4 + axutil_strlen(p_prefix) + 
 
1765
                                  axutil_strlen("CCLog"))); 
 
1766
                                 
1767
1767
                                 /* axutil_strlen("<:>") + 1 = 4 */
1768
1768
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1769
1769
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("CCLog")));
1770
1770
                                  /* axutil_strlen("</:>") + 1 = 5 */
1771
 
 
1772
 
 
1773
 
 
1774
 
 
1775
 
 
1776
 
 
 
1771
                                  
 
1772
                     
 
1773
 
 
1774
                   
 
1775
                   
 
1776
                     
1777
1777
                     /*
1778
1778
                      * parsing CCLog element
1779
1779
                      */
1780
1780
 
1781
 
 
1782
 
 
 
1781
                    
 
1782
                    
1783
1783
                            sprintf(start_input_str, "<%s%sCCLog>",
1784
1784
                                 p_prefix?p_prefix:"",
1785
1785
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1786
 
 
 
1786
                            
1787
1787
                        start_input_str_len = axutil_strlen(start_input_str);
1788
1788
                        sprintf(end_input_str, "</%s%sCCLog>",
1789
1789
                                 p_prefix?p_prefix:"",
1790
1790
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1791
1791
                        end_input_str_len = axutil_strlen(end_input_str);
1792
 
 
 
1792
                    
1793
1793
                           text_value_6 = _getLogsResponseType->property_CCLog;
1794
 
 
 
1794
                           
1795
1795
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1796
 
 
1797
 
 
 
1796
                           
 
1797
                            
1798
1798
                           text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1799
1799
                           if (text_value_6_temp)
1800
1800
                           {
1805
1805
                           {
1806
1806
                               axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1807
1807
                           }
1808
 
 
 
1808
                           
1809
1809
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1810
 
 
1811
 
 
 
1810
                           
 
1811
                     
1812
1812
                     AXIS2_FREE(env->allocator,start_input_str);
1813
1813
                     AXIS2_FREE(env->allocator,end_input_str);
1814
 
                 }
1815
 
 
1816
 
 
 
1814
                 } 
 
1815
 
 
1816
                 
1817
1817
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1818
1818
                       {
1819
1819
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1820
1820
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1821
1821
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1822
 
 
 
1822
                           
1823
1823
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1824
1824
                                            "http://eucalyptus.ucsb.edu/",
1825
1825
                                            p_prefix));
1826
1826
                       }
1827
 
 
 
1827
                      
1828
1828
 
1829
1829
                   if (!_getLogsResponseType->is_valid_NCLog)
1830
1830
                   {
1831
 
 
 
1831
                      
1832
1832
                           /* no need to complain for minoccurs=0 element */
1833
 
 
1834
 
 
 
1833
                            
 
1834
                          
1835
1835
                   }
1836
1836
                   else
1837
1837
                   {
1838
1838
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1839
 
                                 (4 + axutil_strlen(p_prefix) +
1840
 
                                  axutil_strlen("NCLog")));
1841
 
 
 
1839
                                 (4 + axutil_strlen(p_prefix) + 
 
1840
                                  axutil_strlen("NCLog"))); 
 
1841
                                 
1842
1842
                                 /* axutil_strlen("<:>") + 1 = 4 */
1843
1843
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1844
1844
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("NCLog")));
1845
1845
                                  /* axutil_strlen("</:>") + 1 = 5 */
1846
 
 
1847
 
 
1848
 
 
1849
 
 
1850
 
 
1851
 
 
 
1846
                                  
 
1847
                     
 
1848
 
 
1849
                   
 
1850
                   
 
1851
                     
1852
1852
                     /*
1853
1853
                      * parsing NCLog element
1854
1854
                      */
1855
1855
 
1856
 
 
1857
 
 
 
1856
                    
 
1857
                    
1858
1858
                            sprintf(start_input_str, "<%s%sNCLog>",
1859
1859
                                 p_prefix?p_prefix:"",
1860
1860
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1861
 
 
 
1861
                            
1862
1862
                        start_input_str_len = axutil_strlen(start_input_str);
1863
1863
                        sprintf(end_input_str, "</%s%sNCLog>",
1864
1864
                                 p_prefix?p_prefix:"",
1865
1865
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1866
1866
                        end_input_str_len = axutil_strlen(end_input_str);
1867
 
 
 
1867
                    
1868
1868
                           text_value_7 = _getLogsResponseType->property_NCLog;
1869
 
 
 
1869
                           
1870
1870
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1871
 
 
1872
 
 
 
1871
                           
 
1872
                            
1873
1873
                           text_value_7_temp = axutil_xml_quote_string(env, text_value_7, AXIS2_TRUE);
1874
1874
                           if (text_value_7_temp)
1875
1875
                           {
1880
1880
                           {
1881
1881
                               axutil_stream_write(stream, env, text_value_7, axutil_strlen(text_value_7));
1882
1882
                           }
1883
 
 
 
1883
                           
1884
1884
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1885
 
 
1886
 
 
 
1885
                           
 
1886
                     
1887
1887
                     AXIS2_FREE(env->allocator,start_input_str);
1888
1888
                     AXIS2_FREE(env->allocator,end_input_str);
1889
 
                 }
1890
 
 
1891
 
 
 
1889
                 } 
 
1890
 
 
1891
                 
1892
1892
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1893
1893
                       {
1894
1894
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1895
1895
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1896
1896
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1897
 
 
 
1897
                           
1898
1898
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1899
1899
                                            "http://eucalyptus.ucsb.edu/",
1900
1900
                                            p_prefix));
1901
1901
                       }
1902
 
 
 
1902
                      
1903
1903
 
1904
1904
                   if (!_getLogsResponseType->is_valid_httpdLog)
1905
1905
                   {
1906
 
 
 
1906
                      
1907
1907
                           /* no need to complain for minoccurs=0 element */
1908
 
 
1909
 
 
 
1908
                            
 
1909
                          
1910
1910
                   }
1911
1911
                   else
1912
1912
                   {
1913
1913
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1914
 
                                 (4 + axutil_strlen(p_prefix) +
1915
 
                                  axutil_strlen("httpdLog")));
1916
 
 
 
1914
                                 (4 + axutil_strlen(p_prefix) + 
 
1915
                                  axutil_strlen("httpdLog"))); 
 
1916
                                 
1917
1917
                                 /* axutil_strlen("<:>") + 1 = 4 */
1918
1918
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1919
1919
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("httpdLog")));
1920
1920
                                  /* axutil_strlen("</:>") + 1 = 5 */
1921
 
 
1922
 
 
1923
 
 
1924
 
 
1925
 
 
1926
 
 
 
1921
                                  
 
1922
                     
 
1923
 
 
1924
                   
 
1925
                   
 
1926
                     
1927
1927
                     /*
1928
1928
                      * parsing httpdLog element
1929
1929
                      */
1930
1930
 
1931
 
 
1932
 
 
 
1931
                    
 
1932
                    
1933
1933
                            sprintf(start_input_str, "<%s%shttpdLog>",
1934
1934
                                 p_prefix?p_prefix:"",
1935
1935
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1936
 
 
 
1936
                            
1937
1937
                        start_input_str_len = axutil_strlen(start_input_str);
1938
1938
                        sprintf(end_input_str, "</%s%shttpdLog>",
1939
1939
                                 p_prefix?p_prefix:"",
1940
1940
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1941
1941
                        end_input_str_len = axutil_strlen(end_input_str);
1942
 
 
 
1942
                    
1943
1943
                           text_value_8 = _getLogsResponseType->property_httpdLog;
1944
 
 
 
1944
                           
1945
1945
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1946
 
 
1947
 
 
 
1946
                           
 
1947
                            
1948
1948
                           text_value_8_temp = axutil_xml_quote_string(env, text_value_8, AXIS2_TRUE);
1949
1949
                           if (text_value_8_temp)
1950
1950
                           {
1955
1955
                           {
1956
1956
                               axutil_stream_write(stream, env, text_value_8, axutil_strlen(text_value_8));
1957
1957
                           }
1958
 
 
 
1958
                           
1959
1959
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1960
 
 
1961
 
 
 
1960
                           
 
1961
                     
1962
1962
                     AXIS2_FREE(env->allocator,start_input_str);
1963
1963
                     AXIS2_FREE(env->allocator,end_input_str);
1964
 
                 }
1965
 
 
1966
 
 
 
1964
                 } 
 
1965
 
 
1966
                 
1967
1967
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1968
1968
                       {
1969
1969
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1970
1970
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1971
1971
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1972
 
 
 
1972
                           
1973
1973
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1974
1974
                                            "http://eucalyptus.ucsb.edu/",
1975
1975
                                            p_prefix));
1976
1976
                       }
1977
 
 
 
1977
                      
1978
1978
 
1979
1979
                   if (!_getLogsResponseType->is_valid_axis2Log)
1980
1980
                   {
1981
 
 
 
1981
                      
1982
1982
                           /* no need to complain for minoccurs=0 element */
1983
 
 
1984
 
 
 
1983
                            
 
1984
                          
1985
1985
                   }
1986
1986
                   else
1987
1987
                   {
1988
1988
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1989
 
                                 (4 + axutil_strlen(p_prefix) +
1990
 
                                  axutil_strlen("axis2Log")));
1991
 
 
 
1989
                                 (4 + axutil_strlen(p_prefix) + 
 
1990
                                  axutil_strlen("axis2Log"))); 
 
1991
                                 
1992
1992
                                 /* axutil_strlen("<:>") + 1 = 4 */
1993
1993
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1994
1994
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("axis2Log")));
1995
1995
                                  /* axutil_strlen("</:>") + 1 = 5 */
1996
 
 
1997
 
 
1998
 
 
1999
 
 
2000
 
 
2001
 
 
 
1996
                                  
 
1997
                     
 
1998
 
 
1999
                   
 
2000
                   
 
2001
                     
2002
2002
                     /*
2003
2003
                      * parsing axis2Log element
2004
2004
                      */
2005
2005
 
2006
 
 
2007
 
 
 
2006
                    
 
2007
                    
2008
2008
                            sprintf(start_input_str, "<%s%saxis2Log>",
2009
2009
                                 p_prefix?p_prefix:"",
2010
2010
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2011
 
 
 
2011
                            
2012
2012
                        start_input_str_len = axutil_strlen(start_input_str);
2013
2013
                        sprintf(end_input_str, "</%s%saxis2Log>",
2014
2014
                                 p_prefix?p_prefix:"",
2015
2015
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
2016
2016
                        end_input_str_len = axutil_strlen(end_input_str);
2017
 
 
 
2017
                    
2018
2018
                           text_value_9 = _getLogsResponseType->property_axis2Log;
2019
 
 
 
2019
                           
2020
2020
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
2021
 
 
2022
 
 
 
2021
                           
 
2022
                            
2023
2023
                           text_value_9_temp = axutil_xml_quote_string(env, text_value_9, AXIS2_TRUE);
2024
2024
                           if (text_value_9_temp)
2025
2025
                           {
2030
2030
                           {
2031
2031
                               axutil_stream_write(stream, env, text_value_9, axutil_strlen(text_value_9));
2032
2032
                           }
2033
 
 
 
2033
                           
2034
2034
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
2035
 
 
2036
 
 
 
2035
                           
 
2036
                     
2037
2037
                     AXIS2_FREE(env->allocator,start_input_str);
2038
2038
                     AXIS2_FREE(env->allocator,end_input_str);
2039
 
                 }
2040
 
 
2041
 
 
 
2039
                 } 
 
2040
 
 
2041
                 
2042
2042
 
2043
2043
            return parent;
2044
2044
        }
2045
2045
 
2046
2046
 
2047
 
 
 
2047
        
2048
2048
 
2049
2049
            /**
2050
2050
             * getter for correlationId.
2054
2054
                    adb_getLogsResponseType_t* _getLogsResponseType,
2055
2055
                    const axutil_env_t *env)
2056
2056
             {
2057
 
 
 
2057
                
2058
2058
                    AXIS2_ENV_CHECK(env, NULL);
2059
2059
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2060
 
 
 
2060
                  
2061
2061
 
2062
2062
                return _getLogsResponseType->property_correlationId;
2063
2063
             }
2071
2071
                    const axutil_env_t *env,
2072
2072
                    const axis2_char_t*  arg_correlationId)
2073
2073
             {
2074
 
 
 
2074
                
2075
2075
 
2076
2076
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2077
2077
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2078
 
 
 
2078
                
2079
2079
                if(_getLogsResponseType->is_valid_correlationId &&
2080
2080
                        arg_correlationId == _getLogsResponseType->property_correlationId)
2081
2081
                {
2082
 
 
2083
 
                    return AXIS2_SUCCESS;
 
2082
                    
 
2083
                    return AXIS2_SUCCESS; 
2084
2084
                }
2085
2085
 
2086
2086
                adb_getLogsResponseType_reset_correlationId(_getLogsResponseType, env);
2087
2087
 
2088
 
 
 
2088
                
2089
2089
                if(NULL == arg_correlationId)
2090
2090
                {
2091
2091
                    /* We are already done */
2098
2098
                            return AXIS2_FAILURE;
2099
2099
                        }
2100
2100
                        _getLogsResponseType->is_valid_correlationId = AXIS2_TRUE;
2101
 
 
 
2101
                    
2102
2102
                return AXIS2_SUCCESS;
2103
2103
             }
2104
2104
 
2105
 
 
 
2105
             
2106
2106
 
2107
2107
           /**
2108
2108
            * resetter for correlationId
2118
2118
 
2119
2119
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2120
2120
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2121
 
 
2122
 
 
2123
 
 
2124
 
 
2125
 
 
 
2121
               
 
2122
 
 
2123
               
 
2124
            
 
2125
                
2126
2126
                if(_getLogsResponseType->property_correlationId != NULL)
2127
2127
                {
2128
 
 
2129
 
 
 
2128
                   
 
2129
                   
2130
2130
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_correlationId);
2131
2131
                     _getLogsResponseType->property_correlationId = NULL;
2132
2132
                }
2133
 
 
2134
 
 
2135
 
 
2136
 
                _getLogsResponseType->is_valid_correlationId = AXIS2_FALSE;
 
2133
            
 
2134
                
 
2135
                
 
2136
                _getLogsResponseType->is_valid_correlationId = AXIS2_FALSE; 
2137
2137
               return AXIS2_SUCCESS;
2138
2138
           }
2139
2139
 
2147
2147
           {
2148
2148
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2149
2149
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2150
 
 
 
2150
               
2151
2151
               return !_getLogsResponseType->is_valid_correlationId;
2152
2152
           }
2153
2153
 
2162
2162
               return adb_getLogsResponseType_reset_correlationId(_getLogsResponseType, env);
2163
2163
           }
2164
2164
 
2165
 
 
 
2165
           
2166
2166
 
2167
2167
            /**
2168
2168
             * getter for userId.
2172
2172
                    adb_getLogsResponseType_t* _getLogsResponseType,
2173
2173
                    const axutil_env_t *env)
2174
2174
             {
2175
 
 
 
2175
                
2176
2176
                    AXIS2_ENV_CHECK(env, NULL);
2177
2177
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2178
 
 
 
2178
                  
2179
2179
 
2180
2180
                return _getLogsResponseType->property_userId;
2181
2181
             }
2189
2189
                    const axutil_env_t *env,
2190
2190
                    const axis2_char_t*  arg_userId)
2191
2191
             {
2192
 
 
 
2192
                
2193
2193
 
2194
2194
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2195
2195
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2196
 
 
 
2196
                
2197
2197
                if(_getLogsResponseType->is_valid_userId &&
2198
2198
                        arg_userId == _getLogsResponseType->property_userId)
2199
2199
                {
2200
 
 
2201
 
                    return AXIS2_SUCCESS;
 
2200
                    
 
2201
                    return AXIS2_SUCCESS; 
2202
2202
                }
2203
2203
 
2204
2204
                adb_getLogsResponseType_reset_userId(_getLogsResponseType, env);
2205
2205
 
2206
 
 
 
2206
                
2207
2207
                if(NULL == arg_userId)
2208
2208
                {
2209
2209
                    /* We are already done */
2216
2216
                            return AXIS2_FAILURE;
2217
2217
                        }
2218
2218
                        _getLogsResponseType->is_valid_userId = AXIS2_TRUE;
2219
 
 
 
2219
                    
2220
2220
                return AXIS2_SUCCESS;
2221
2221
             }
2222
2222
 
2223
 
 
 
2223
             
2224
2224
 
2225
2225
           /**
2226
2226
            * resetter for userId
2236
2236
 
2237
2237
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2238
2238
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2239
 
 
2240
 
 
2241
 
 
2242
 
 
2243
 
 
 
2239
               
 
2240
 
 
2241
               
 
2242
            
 
2243
                
2244
2244
                if(_getLogsResponseType->property_userId != NULL)
2245
2245
                {
2246
 
 
2247
 
 
 
2246
                   
 
2247
                   
2248
2248
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_userId);
2249
2249
                     _getLogsResponseType->property_userId = NULL;
2250
2250
                }
2251
 
 
2252
 
 
2253
 
 
2254
 
                _getLogsResponseType->is_valid_userId = AXIS2_FALSE;
 
2251
            
 
2252
                
 
2253
                
 
2254
                _getLogsResponseType->is_valid_userId = AXIS2_FALSE; 
2255
2255
               return AXIS2_SUCCESS;
2256
2256
           }
2257
2257
 
2265
2265
           {
2266
2266
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2267
2267
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2268
 
 
 
2268
               
2269
2269
               return !_getLogsResponseType->is_valid_userId;
2270
2270
           }
2271
2271
 
2280
2280
               return adb_getLogsResponseType_reset_userId(_getLogsResponseType, env);
2281
2281
           }
2282
2282
 
2283
 
 
 
2283
           
2284
2284
 
2285
2285
            /**
2286
2286
             * getter for statusMessage.
2290
2290
                    adb_getLogsResponseType_t* _getLogsResponseType,
2291
2291
                    const axutil_env_t *env)
2292
2292
             {
2293
 
 
 
2293
                
2294
2294
                    AXIS2_ENV_CHECK(env, NULL);
2295
2295
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2296
 
 
 
2296
                  
2297
2297
 
2298
2298
                return _getLogsResponseType->property_statusMessage;
2299
2299
             }
2307
2307
                    const axutil_env_t *env,
2308
2308
                    const axis2_char_t*  arg_statusMessage)
2309
2309
             {
2310
 
 
 
2310
                
2311
2311
 
2312
2312
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2313
2313
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2314
 
 
 
2314
                
2315
2315
                if(_getLogsResponseType->is_valid_statusMessage &&
2316
2316
                        arg_statusMessage == _getLogsResponseType->property_statusMessage)
2317
2317
                {
2318
 
 
2319
 
                    return AXIS2_SUCCESS;
 
2318
                    
 
2319
                    return AXIS2_SUCCESS; 
2320
2320
                }
2321
2321
 
2322
2322
                adb_getLogsResponseType_reset_statusMessage(_getLogsResponseType, env);
2323
2323
 
2324
 
 
 
2324
                
2325
2325
                if(NULL == arg_statusMessage)
2326
2326
                {
2327
2327
                    /* We are already done */
2334
2334
                            return AXIS2_FAILURE;
2335
2335
                        }
2336
2336
                        _getLogsResponseType->is_valid_statusMessage = AXIS2_TRUE;
2337
 
 
 
2337
                    
2338
2338
                return AXIS2_SUCCESS;
2339
2339
             }
2340
2340
 
2341
 
 
 
2341
             
2342
2342
 
2343
2343
           /**
2344
2344
            * resetter for statusMessage
2354
2354
 
2355
2355
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2356
2356
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2357
 
 
2358
 
 
2359
 
 
2360
 
 
2361
 
 
 
2357
               
 
2358
 
 
2359
               
 
2360
            
 
2361
                
2362
2362
                if(_getLogsResponseType->property_statusMessage != NULL)
2363
2363
                {
2364
 
 
2365
 
 
 
2364
                   
 
2365
                   
2366
2366
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_statusMessage);
2367
2367
                     _getLogsResponseType->property_statusMessage = NULL;
2368
2368
                }
2369
 
 
2370
 
 
2371
 
 
2372
 
                _getLogsResponseType->is_valid_statusMessage = AXIS2_FALSE;
 
2369
            
 
2370
                
 
2371
                
 
2372
                _getLogsResponseType->is_valid_statusMessage = AXIS2_FALSE; 
2373
2373
               return AXIS2_SUCCESS;
2374
2374
           }
2375
2375
 
2383
2383
           {
2384
2384
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2385
2385
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2386
 
 
 
2386
               
2387
2387
               return !_getLogsResponseType->is_valid_statusMessage;
2388
2388
           }
2389
2389
 
2398
2398
               return adb_getLogsResponseType_reset_statusMessage(_getLogsResponseType, env);
2399
2399
           }
2400
2400
 
2401
 
 
 
2401
           
2402
2402
 
2403
2403
            /**
2404
2404
             * getter for return.
2408
2408
                    adb_getLogsResponseType_t* _getLogsResponseType,
2409
2409
                    const axutil_env_t *env)
2410
2410
             {
2411
 
 
 
2411
                
2412
2412
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
2413
2413
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, (axis2_bool_t)0);
2414
 
 
 
2414
                  
2415
2415
 
2416
2416
                return _getLogsResponseType->property_return;
2417
2417
             }
2425
2425
                    const axutil_env_t *env,
2426
2426
                    axis2_bool_t  arg_return)
2427
2427
             {
2428
 
 
 
2428
                
2429
2429
 
2430
2430
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2431
2431
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2432
 
 
 
2432
                
2433
2433
                if(_getLogsResponseType->is_valid_return &&
2434
2434
                        arg_return == _getLogsResponseType->property_return)
2435
2435
                {
2436
 
 
2437
 
                    return AXIS2_SUCCESS;
 
2436
                    
 
2437
                    return AXIS2_SUCCESS; 
2438
2438
                }
2439
2439
 
2440
2440
                adb_getLogsResponseType_reset_return(_getLogsResponseType, env);
2441
2441
 
2442
2442
                _getLogsResponseType->property_return = arg_return;
2443
2443
                        _getLogsResponseType->is_valid_return = AXIS2_TRUE;
2444
 
 
 
2444
                    
2445
2445
                return AXIS2_SUCCESS;
2446
2446
             }
2447
2447
 
2448
 
 
 
2448
             
2449
2449
 
2450
2450
           /**
2451
2451
            * resetter for return
2461
2461
 
2462
2462
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2463
2463
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2464
 
 
2465
 
 
2466
 
               _getLogsResponseType->is_valid_return = AXIS2_FALSE;
 
2464
               
 
2465
 
 
2466
               _getLogsResponseType->is_valid_return = AXIS2_FALSE; 
2467
2467
               return AXIS2_SUCCESS;
2468
2468
           }
2469
2469
 
2477
2477
           {
2478
2478
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2479
2479
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2480
 
 
 
2480
               
2481
2481
               return !_getLogsResponseType->is_valid_return;
2482
2482
           }
2483
2483
 
2492
2492
               return adb_getLogsResponseType_reset_return(_getLogsResponseType, env);
2493
2493
           }
2494
2494
 
2495
 
 
 
2495
           
2496
2496
 
2497
2497
            /**
2498
2498
             * getter for serviceTag.
2502
2502
                    adb_getLogsResponseType_t* _getLogsResponseType,
2503
2503
                    const axutil_env_t *env)
2504
2504
             {
2505
 
 
 
2505
                
2506
2506
                    AXIS2_ENV_CHECK(env, NULL);
2507
2507
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2508
 
 
 
2508
                  
2509
2509
 
2510
2510
                return _getLogsResponseType->property_serviceTag;
2511
2511
             }
2519
2519
                    const axutil_env_t *env,
2520
2520
                    const axis2_char_t*  arg_serviceTag)
2521
2521
             {
2522
 
 
 
2522
                
2523
2523
 
2524
2524
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2525
2525
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2526
 
 
 
2526
                
2527
2527
                if(_getLogsResponseType->is_valid_serviceTag &&
2528
2528
                        arg_serviceTag == _getLogsResponseType->property_serviceTag)
2529
2529
                {
2530
 
 
2531
 
                    return AXIS2_SUCCESS;
 
2530
                    
 
2531
                    return AXIS2_SUCCESS; 
2532
2532
                }
2533
2533
 
2534
2534
                adb_getLogsResponseType_reset_serviceTag(_getLogsResponseType, env);
2535
2535
 
2536
 
 
 
2536
                
2537
2537
                if(NULL == arg_serviceTag)
2538
2538
                {
2539
2539
                    /* We are already done */
2546
2546
                            return AXIS2_FAILURE;
2547
2547
                        }
2548
2548
                        _getLogsResponseType->is_valid_serviceTag = AXIS2_TRUE;
2549
 
 
 
2549
                    
2550
2550
                return AXIS2_SUCCESS;
2551
2551
             }
2552
2552
 
2553
 
 
 
2553
             
2554
2554
 
2555
2555
           /**
2556
2556
            * resetter for serviceTag
2566
2566
 
2567
2567
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2568
2568
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2569
 
 
2570
 
 
2571
 
 
2572
 
 
2573
 
 
 
2569
               
 
2570
 
 
2571
               
 
2572
            
 
2573
                
2574
2574
                if(_getLogsResponseType->property_serviceTag != NULL)
2575
2575
                {
2576
 
 
2577
 
 
 
2576
                   
 
2577
                   
2578
2578
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_serviceTag);
2579
2579
                     _getLogsResponseType->property_serviceTag = NULL;
2580
2580
                }
2581
 
 
2582
 
 
2583
 
 
2584
 
                _getLogsResponseType->is_valid_serviceTag = AXIS2_FALSE;
 
2581
            
 
2582
                
 
2583
                
 
2584
                _getLogsResponseType->is_valid_serviceTag = AXIS2_FALSE; 
2585
2585
               return AXIS2_SUCCESS;
2586
2586
           }
2587
2587
 
2595
2595
           {
2596
2596
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2597
2597
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2598
 
 
 
2598
               
2599
2599
               return !_getLogsResponseType->is_valid_serviceTag;
2600
2600
           }
2601
2601
 
2610
2610
               return adb_getLogsResponseType_reset_serviceTag(_getLogsResponseType, env);
2611
2611
           }
2612
2612
 
2613
 
 
 
2613
           
2614
2614
 
2615
2615
            /**
2616
2616
             * getter for CCLog.
2620
2620
                    adb_getLogsResponseType_t* _getLogsResponseType,
2621
2621
                    const axutil_env_t *env)
2622
2622
             {
2623
 
 
 
2623
                
2624
2624
                    AXIS2_ENV_CHECK(env, NULL);
2625
2625
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2626
 
 
 
2626
                  
2627
2627
 
2628
2628
                return _getLogsResponseType->property_CCLog;
2629
2629
             }
2637
2637
                    const axutil_env_t *env,
2638
2638
                    const axis2_char_t*  arg_CCLog)
2639
2639
             {
2640
 
 
 
2640
                
2641
2641
 
2642
2642
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2643
2643
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2644
 
 
 
2644
                
2645
2645
                if(_getLogsResponseType->is_valid_CCLog &&
2646
2646
                        arg_CCLog == _getLogsResponseType->property_CCLog)
2647
2647
                {
2648
 
 
2649
 
                    return AXIS2_SUCCESS;
 
2648
                    
 
2649
                    return AXIS2_SUCCESS; 
2650
2650
                }
2651
2651
 
2652
2652
                adb_getLogsResponseType_reset_CCLog(_getLogsResponseType, env);
2653
2653
 
2654
 
 
 
2654
                
2655
2655
                if(NULL == arg_CCLog)
2656
2656
                {
2657
2657
                    /* We are already done */
2664
2664
                            return AXIS2_FAILURE;
2665
2665
                        }
2666
2666
                        _getLogsResponseType->is_valid_CCLog = AXIS2_TRUE;
2667
 
 
 
2667
                    
2668
2668
                return AXIS2_SUCCESS;
2669
2669
             }
2670
2670
 
2671
 
 
 
2671
             
2672
2672
 
2673
2673
           /**
2674
2674
            * resetter for CCLog
2684
2684
 
2685
2685
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2686
2686
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2687
 
 
2688
 
 
2689
 
 
2690
 
 
2691
 
 
 
2687
               
 
2688
 
 
2689
               
 
2690
            
 
2691
                
2692
2692
                if(_getLogsResponseType->property_CCLog != NULL)
2693
2693
                {
2694
 
 
2695
 
 
 
2694
                   
 
2695
                   
2696
2696
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_CCLog);
2697
2697
                     _getLogsResponseType->property_CCLog = NULL;
2698
2698
                }
2699
 
 
2700
 
 
2701
 
 
2702
 
                _getLogsResponseType->is_valid_CCLog = AXIS2_FALSE;
 
2699
            
 
2700
                
 
2701
                
 
2702
                _getLogsResponseType->is_valid_CCLog = AXIS2_FALSE; 
2703
2703
               return AXIS2_SUCCESS;
2704
2704
           }
2705
2705
 
2713
2713
           {
2714
2714
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2715
2715
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2716
 
 
 
2716
               
2717
2717
               return !_getLogsResponseType->is_valid_CCLog;
2718
2718
           }
2719
2719
 
2728
2728
               return adb_getLogsResponseType_reset_CCLog(_getLogsResponseType, env);
2729
2729
           }
2730
2730
 
2731
 
 
 
2731
           
2732
2732
 
2733
2733
            /**
2734
2734
             * getter for NCLog.
2738
2738
                    adb_getLogsResponseType_t* _getLogsResponseType,
2739
2739
                    const axutil_env_t *env)
2740
2740
             {
2741
 
 
 
2741
                
2742
2742
                    AXIS2_ENV_CHECK(env, NULL);
2743
2743
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2744
 
 
 
2744
                  
2745
2745
 
2746
2746
                return _getLogsResponseType->property_NCLog;
2747
2747
             }
2755
2755
                    const axutil_env_t *env,
2756
2756
                    const axis2_char_t*  arg_NCLog)
2757
2757
             {
2758
 
 
 
2758
                
2759
2759
 
2760
2760
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2761
2761
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2762
 
 
 
2762
                
2763
2763
                if(_getLogsResponseType->is_valid_NCLog &&
2764
2764
                        arg_NCLog == _getLogsResponseType->property_NCLog)
2765
2765
                {
2766
 
 
2767
 
                    return AXIS2_SUCCESS;
 
2766
                    
 
2767
                    return AXIS2_SUCCESS; 
2768
2768
                }
2769
2769
 
2770
2770
                adb_getLogsResponseType_reset_NCLog(_getLogsResponseType, env);
2771
2771
 
2772
 
 
 
2772
                
2773
2773
                if(NULL == arg_NCLog)
2774
2774
                {
2775
2775
                    /* We are already done */
2782
2782
                            return AXIS2_FAILURE;
2783
2783
                        }
2784
2784
                        _getLogsResponseType->is_valid_NCLog = AXIS2_TRUE;
2785
 
 
 
2785
                    
2786
2786
                return AXIS2_SUCCESS;
2787
2787
             }
2788
2788
 
2789
 
 
 
2789
             
2790
2790
 
2791
2791
           /**
2792
2792
            * resetter for NCLog
2802
2802
 
2803
2803
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2804
2804
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2805
 
 
2806
 
 
2807
 
 
2808
 
 
2809
 
 
 
2805
               
 
2806
 
 
2807
               
 
2808
            
 
2809
                
2810
2810
                if(_getLogsResponseType->property_NCLog != NULL)
2811
2811
                {
2812
 
 
2813
 
 
 
2812
                   
 
2813
                   
2814
2814
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_NCLog);
2815
2815
                     _getLogsResponseType->property_NCLog = NULL;
2816
2816
                }
2817
 
 
2818
 
 
2819
 
 
2820
 
                _getLogsResponseType->is_valid_NCLog = AXIS2_FALSE;
 
2817
            
 
2818
                
 
2819
                
 
2820
                _getLogsResponseType->is_valid_NCLog = AXIS2_FALSE; 
2821
2821
               return AXIS2_SUCCESS;
2822
2822
           }
2823
2823
 
2831
2831
           {
2832
2832
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2833
2833
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2834
 
 
 
2834
               
2835
2835
               return !_getLogsResponseType->is_valid_NCLog;
2836
2836
           }
2837
2837
 
2846
2846
               return adb_getLogsResponseType_reset_NCLog(_getLogsResponseType, env);
2847
2847
           }
2848
2848
 
2849
 
 
 
2849
           
2850
2850
 
2851
2851
            /**
2852
2852
             * getter for httpdLog.
2856
2856
                    adb_getLogsResponseType_t* _getLogsResponseType,
2857
2857
                    const axutil_env_t *env)
2858
2858
             {
2859
 
 
 
2859
                
2860
2860
                    AXIS2_ENV_CHECK(env, NULL);
2861
2861
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2862
 
 
 
2862
                  
2863
2863
 
2864
2864
                return _getLogsResponseType->property_httpdLog;
2865
2865
             }
2873
2873
                    const axutil_env_t *env,
2874
2874
                    const axis2_char_t*  arg_httpdLog)
2875
2875
             {
2876
 
 
 
2876
                
2877
2877
 
2878
2878
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2879
2879
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2880
 
 
 
2880
                
2881
2881
                if(_getLogsResponseType->is_valid_httpdLog &&
2882
2882
                        arg_httpdLog == _getLogsResponseType->property_httpdLog)
2883
2883
                {
2884
 
 
2885
 
                    return AXIS2_SUCCESS;
 
2884
                    
 
2885
                    return AXIS2_SUCCESS; 
2886
2886
                }
2887
2887
 
2888
2888
                adb_getLogsResponseType_reset_httpdLog(_getLogsResponseType, env);
2889
2889
 
2890
 
 
 
2890
                
2891
2891
                if(NULL == arg_httpdLog)
2892
2892
                {
2893
2893
                    /* We are already done */
2900
2900
                            return AXIS2_FAILURE;
2901
2901
                        }
2902
2902
                        _getLogsResponseType->is_valid_httpdLog = AXIS2_TRUE;
2903
 
 
 
2903
                    
2904
2904
                return AXIS2_SUCCESS;
2905
2905
             }
2906
2906
 
2907
 
 
 
2907
             
2908
2908
 
2909
2909
           /**
2910
2910
            * resetter for httpdLog
2920
2920
 
2921
2921
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2922
2922
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2923
 
 
2924
 
 
2925
 
 
2926
 
 
2927
 
 
 
2923
               
 
2924
 
 
2925
               
 
2926
            
 
2927
                
2928
2928
                if(_getLogsResponseType->property_httpdLog != NULL)
2929
2929
                {
2930
 
 
2931
 
 
 
2930
                   
 
2931
                   
2932
2932
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_httpdLog);
2933
2933
                     _getLogsResponseType->property_httpdLog = NULL;
2934
2934
                }
2935
 
 
2936
 
 
2937
 
 
2938
 
                _getLogsResponseType->is_valid_httpdLog = AXIS2_FALSE;
 
2935
            
 
2936
                
 
2937
                
 
2938
                _getLogsResponseType->is_valid_httpdLog = AXIS2_FALSE; 
2939
2939
               return AXIS2_SUCCESS;
2940
2940
           }
2941
2941
 
2949
2949
           {
2950
2950
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2951
2951
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
2952
 
 
 
2952
               
2953
2953
               return !_getLogsResponseType->is_valid_httpdLog;
2954
2954
           }
2955
2955
 
2964
2964
               return adb_getLogsResponseType_reset_httpdLog(_getLogsResponseType, env);
2965
2965
           }
2966
2966
 
2967
 
 
 
2967
           
2968
2968
 
2969
2969
            /**
2970
2970
             * getter for axis2Log.
2974
2974
                    adb_getLogsResponseType_t* _getLogsResponseType,
2975
2975
                    const axutil_env_t *env)
2976
2976
             {
2977
 
 
 
2977
                
2978
2978
                    AXIS2_ENV_CHECK(env, NULL);
2979
2979
                    AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, NULL);
2980
 
 
 
2980
                  
2981
2981
 
2982
2982
                return _getLogsResponseType->property_axis2Log;
2983
2983
             }
2991
2991
                    const axutil_env_t *env,
2992
2992
                    const axis2_char_t*  arg_axis2Log)
2993
2993
             {
2994
 
 
 
2994
                
2995
2995
 
2996
2996
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2997
2997
                AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
2998
 
 
 
2998
                
2999
2999
                if(_getLogsResponseType->is_valid_axis2Log &&
3000
3000
                        arg_axis2Log == _getLogsResponseType->property_axis2Log)
3001
3001
                {
3002
 
 
3003
 
                    return AXIS2_SUCCESS;
 
3002
                    
 
3003
                    return AXIS2_SUCCESS; 
3004
3004
                }
3005
3005
 
3006
3006
                adb_getLogsResponseType_reset_axis2Log(_getLogsResponseType, env);
3007
3007
 
3008
 
 
 
3008
                
3009
3009
                if(NULL == arg_axis2Log)
3010
3010
                {
3011
3011
                    /* We are already done */
3018
3018
                            return AXIS2_FAILURE;
3019
3019
                        }
3020
3020
                        _getLogsResponseType->is_valid_axis2Log = AXIS2_TRUE;
3021
 
 
 
3021
                    
3022
3022
                return AXIS2_SUCCESS;
3023
3023
             }
3024
3024
 
3025
 
 
 
3025
             
3026
3026
 
3027
3027
           /**
3028
3028
            * resetter for axis2Log
3038
3038
 
3039
3039
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
3040
3040
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_FAILURE);
3041
 
 
3042
 
 
3043
 
 
3044
 
 
3045
 
 
 
3041
               
 
3042
 
 
3043
               
 
3044
            
 
3045
                
3046
3046
                if(_getLogsResponseType->property_axis2Log != NULL)
3047
3047
                {
3048
 
 
3049
 
 
 
3048
                   
 
3049
                   
3050
3050
                        AXIS2_FREE(env-> allocator, _getLogsResponseType->property_axis2Log);
3051
3051
                     _getLogsResponseType->property_axis2Log = NULL;
3052
3052
                }
3053
 
 
3054
 
 
3055
 
 
3056
 
                _getLogsResponseType->is_valid_axis2Log = AXIS2_FALSE;
 
3053
            
 
3054
                
 
3055
                
 
3056
                _getLogsResponseType->is_valid_axis2Log = AXIS2_FALSE; 
3057
3057
               return AXIS2_SUCCESS;
3058
3058
           }
3059
3059
 
3067
3067
           {
3068
3068
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
3069
3069
               AXIS2_PARAM_CHECK(env->error, _getLogsResponseType, AXIS2_TRUE);
3070
 
 
 
3070
               
3071
3071
               return !_getLogsResponseType->is_valid_axis2Log;
3072
3072
           }
3073
3073
 
3082
3082
               return adb_getLogsResponseType_reset_axis2Log(_getLogsResponseType, env);
3083
3083
           }
3084
3084
 
3085
 
 
 
3085
           
3086
3086