← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gatherlog/generated/adb_getLogsType.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_getLogsType.c
8
8
         */
9
9
 
10
10
        #include "adb_getLogsType.h"
11
 
 
 
11
        
12
12
                /*
13
13
                 * This type was generated from the piece of schema that had
14
14
                 * name = getLogsType
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_getLogsType
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
            
54
54
        };
55
55
 
56
56
 
57
57
       /************************* Private Function prototypes ********************************/
58
 
 
 
58
        
59
59
 
60
60
                axis2_status_t AXIS2_CALL
61
61
                adb_getLogsType_set_correlationId_nil(
62
62
                        adb_getLogsType_t* _getLogsType,
63
63
                        const axutil_env_t *env);
64
 
 
 
64
            
65
65
 
66
66
                axis2_status_t AXIS2_CALL
67
67
                adb_getLogsType_set_userId_nil(
68
68
                        adb_getLogsType_t* _getLogsType,
69
69
                        const axutil_env_t *env);
70
 
 
 
70
            
71
71
 
72
72
                axis2_status_t AXIS2_CALL
73
73
                adb_getLogsType_set_return_nil(
74
74
                        adb_getLogsType_t* _getLogsType,
75
75
                        const axutil_env_t *env);
76
 
 
 
76
            
77
77
 
78
78
                axis2_status_t AXIS2_CALL
79
79
                adb_getLogsType_set_serviceTag_nil(
80
80
                        adb_getLogsType_t* _getLogsType,
81
81
                        const axutil_env_t *env);
82
 
 
 
82
            
83
83
 
84
84
 
85
85
       /************************* Function Implmentations ********************************/
88
88
            const axutil_env_t *env)
89
89
        {
90
90
            adb_getLogsType_t *_getLogsType = NULL;
91
 
 
 
91
            
92
92
            AXIS2_ENV_CHECK(env, NULL);
93
93
 
94
94
            _getLogsType = (adb_getLogsType_t *) AXIS2_MALLOC(env->
111
111
            _getLogsType->is_valid_return  = AXIS2_FALSE;
112
112
            _getLogsType->property_serviceTag  = NULL;
113
113
                  _getLogsType->is_valid_serviceTag  = AXIS2_FALSE;
114
 
 
 
114
            
115
115
 
116
116
            return _getLogsType;
117
117
        }
121
121
                adb_getLogsType_t* _getLogsType,
122
122
                const axutil_env_t *env)
123
123
        {
124
 
 
 
124
            
125
125
 
126
126
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
127
127
            AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
131
131
            adb_getLogsType_reset_statusMessage(_getLogsType, env);
132
132
            adb_getLogsType_reset_return(_getLogsType, env);
133
133
            adb_getLogsType_reset_serviceTag(_getLogsType, env);
134
 
 
 
134
            
135
135
 
136
136
            if(_getLogsType)
137
137
            {
142
142
        }
143
143
 
144
144
 
145
 
 
 
145
        
146
146
 
147
147
        axis2_status_t AXIS2_CALL
148
148
        adb_getLogsType_deserialize(
153
153
                axis2_bool_t dont_care_minoccurs)
154
154
        {
155
155
          axiom_node_t *parent = *dp_parent;
156
 
 
 
156
          
157
157
          axis2_status_t status = AXIS2_SUCCESS;
158
 
 
 
158
           
159
159
             axis2_char_t* text_value = NULL;
160
160
             axutil_qname_t *qname = NULL;
161
 
 
162
 
            axutil_qname_t *element_qname = NULL;
163
 
 
 
161
          
 
162
            axutil_qname_t *element_qname = NULL; 
 
163
            
164
164
               axiom_node_t *first_node = NULL;
165
165
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
166
166
               axiom_node_t *current_node = NULL;
167
167
               axiom_element_t *current_element = NULL;
168
 
 
 
168
            
169
169
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
170
170
            AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
171
171
 
172
 
 
173
 
 
 
172
            
 
173
              
174
174
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
175
175
              {
176
176
                  parent = axiom_node_get_next_sibling(parent, env);
178
178
              if (NULL == parent)
179
179
              {
180
180
                /* This should be checked before everything */
181
 
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
 
181
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
182
182
                            "Failed in building adb object for getLogsType : "
183
183
                            "NULL elemenet can not be passed to deserialize");
184
184
                return AXIS2_FAILURE;
185
185
              }
186
 
 
187
 
 
 
186
              
 
187
                      
188
188
                      first_node = axiom_node_get_first_child(parent, env);
189
 
 
190
 
 
191
 
 
192
 
 
 
189
                      
 
190
                    
 
191
 
 
192
                     
193
193
                     /*
194
194
                      * building correlationId element
195
195
                      */
196
 
 
197
 
 
198
 
 
 
196
                     
 
197
                     
 
198
                     
199
199
                                   current_node = first_node;
200
200
                                   is_early_node_valid = AXIS2_FALSE;
201
 
 
202
 
 
 
201
                                   
 
202
                                   
203
203
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
204
204
                                    {
205
205
                                        current_node = axiom_node_get_next_sibling(current_node, env);
209
209
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
210
210
                                        qname = axiom_element_get_qname(current_element, env, current_node);
211
211
                                    }
212
 
 
 
212
                                   
213
213
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
214
 
 
215
 
 
216
 
                           if (
 
214
                                 
 
215
 
 
216
                           if ( 
217
217
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
218
218
                           {
219
219
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
220
220
                              {
221
221
                                is_early_node_valid = AXIS2_TRUE;
222
222
                              }
223
 
 
224
 
 
 
223
                              
 
224
                                 
225
225
                                      text_value = axiom_element_get_text(current_element, env, current_node);
226
226
                                      if(text_value != NULL)
227
227
                                      {
228
228
                                            status = adb_getLogsType_set_correlationId(_getLogsType, env,
229
229
                                                               text_value);
230
230
                                      }
231
 
 
 
231
                                      
232
232
                                      else
233
233
                                      {
234
234
                                            /*
235
235
                                             * axis2_qname_t *qname = NULL;
236
236
                                             * axiom_attribute_t *the_attri = NULL;
237
 
                                             *
 
237
                                             * 
238
238
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
239
239
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
240
240
                                             */
252
252
                                                 axutil_hash_index_t *hi;
253
253
                                                 void *val;
254
254
                                                 const void *key;
255
 
 
256
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
255
                                        
 
256
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
257
257
                                                 {
258
258
                                                     axutil_hash_this(hi, &key, NULL, &val);
259
 
 
 
259
                                                     
260
260
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
261
261
                                                     {
262
262
                                                         the_attri = (axiom_attribute_t*)val;
287
287
                                                                   "");
288
288
                                            }
289
289
                                      }
290
 
 
 
290
                                      
291
291
                                 if(AXIS2_FAILURE ==  status)
292
292
                                 {
293
293
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
298
298
                                     return AXIS2_FAILURE;
299
299
                                 }
300
300
                              }
301
 
 
 
301
                           
302
302
                  if(element_qname)
303
303
                  {
304
304
                     axutil_qname_free(element_qname, env);
305
305
                     element_qname = NULL;
306
306
                  }
307
 
 
308
 
 
309
 
 
 
307
                 
 
308
 
 
309
                     
310
310
                     /*
311
311
                      * building userId element
312
312
                      */
313
 
 
314
 
 
315
 
 
 
313
                     
 
314
                     
 
315
                     
316
316
                                    /*
317
317
                                     * because elements are ordered this works fine
318
318
                                     */
319
 
 
320
 
 
 
319
                                  
 
320
                                   
321
321
                                   if(current_node != NULL && is_early_node_valid)
322
322
                                   {
323
323
                                       current_node = axiom_node_get_next_sibling(current_node, env);
324
 
 
325
 
 
 
324
                                       
 
325
                                       
326
326
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
327
327
                                        {
328
328
                                            current_node = axiom_node_get_next_sibling(current_node, env);
332
332
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
333
333
                                            qname = axiom_element_get_qname(current_element, env, current_node);
334
334
                                        }
335
 
 
 
335
                                       
336
336
                                   }
337
337
                                   is_early_node_valid = AXIS2_FALSE;
338
 
 
 
338
                                 
339
339
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
340
 
 
341
 
 
342
 
                           if (
 
340
                                 
 
341
 
 
342
                           if ( 
343
343
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
344
344
                           {
345
345
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
346
346
                              {
347
347
                                is_early_node_valid = AXIS2_TRUE;
348
348
                              }
349
 
 
350
 
 
 
349
                              
 
350
                                 
351
351
                                      text_value = axiom_element_get_text(current_element, env, current_node);
352
352
                                      if(text_value != NULL)
353
353
                                      {
354
354
                                            status = adb_getLogsType_set_userId(_getLogsType, env,
355
355
                                                               text_value);
356
356
                                      }
357
 
 
 
357
                                      
358
358
                                      else
359
359
                                      {
360
360
                                            /*
361
361
                                             * axis2_qname_t *qname = NULL;
362
362
                                             * axiom_attribute_t *the_attri = NULL;
363
 
                                             *
 
363
                                             * 
364
364
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
365
365
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
366
366
                                             */
378
378
                                                 axutil_hash_index_t *hi;
379
379
                                                 void *val;
380
380
                                                 const void *key;
381
 
 
382
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
381
                                        
 
382
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
383
383
                                                 {
384
384
                                                     axutil_hash_this(hi, &key, NULL, &val);
385
 
 
 
385
                                                     
386
386
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
387
387
                                                     {
388
388
                                                         the_attri = (axiom_attribute_t*)val;
413
413
                                                                   "");
414
414
                                            }
415
415
                                      }
416
 
 
 
416
                                      
417
417
                                 if(AXIS2_FAILURE ==  status)
418
418
                                 {
419
419
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
424
424
                                     return AXIS2_FAILURE;
425
425
                                 }
426
426
                              }
427
 
 
 
427
                           
428
428
                  if(element_qname)
429
429
                  {
430
430
                     axutil_qname_free(element_qname, env);
431
431
                     element_qname = NULL;
432
432
                  }
433
 
 
434
 
 
435
 
 
 
433
                 
 
434
 
 
435
                     
436
436
                     /*
437
437
                      * building statusMessage element
438
438
                      */
439
 
 
440
 
 
441
 
 
 
439
                     
 
440
                     
 
441
                     
442
442
                                    /*
443
443
                                     * because elements are ordered this works fine
444
444
                                     */
445
 
 
446
 
 
 
445
                                  
 
446
                                   
447
447
                                   if(current_node != NULL && is_early_node_valid)
448
448
                                   {
449
449
                                       current_node = axiom_node_get_next_sibling(current_node, env);
450
 
 
451
 
 
 
450
                                       
 
451
                                       
452
452
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
453
453
                                        {
454
454
                                            current_node = axiom_node_get_next_sibling(current_node, env);
458
458
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
459
459
                                            qname = axiom_element_get_qname(current_element, env, current_node);
460
460
                                        }
461
 
 
 
461
                                       
462
462
                                   }
463
463
                                   is_early_node_valid = AXIS2_FALSE;
464
 
 
 
464
                                 
465
465
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
466
 
 
467
 
 
468
 
                           if (
 
466
                                 
 
467
 
 
468
                           if ( 
469
469
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
470
470
                           {
471
471
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
472
472
                              {
473
473
                                is_early_node_valid = AXIS2_TRUE;
474
474
                              }
475
 
 
476
 
 
 
475
                              
 
476
                                 
477
477
                                      text_value = axiom_element_get_text(current_element, env, current_node);
478
478
                                      if(text_value != NULL)
479
479
                                      {
480
480
                                            status = adb_getLogsType_set_statusMessage(_getLogsType, env,
481
481
                                                               text_value);
482
482
                                      }
483
 
 
 
483
                                      
484
484
                                 if(AXIS2_FAILURE ==  status)
485
485
                                 {
486
486
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
491
491
                                     return AXIS2_FAILURE;
492
492
                                 }
493
493
                              }
494
 
 
 
494
                           
495
495
                  if(element_qname)
496
496
                  {
497
497
                     axutil_qname_free(element_qname, env);
498
498
                     element_qname = NULL;
499
499
                  }
500
 
 
501
 
 
502
 
 
 
500
                 
 
501
 
 
502
                     
503
503
                     /*
504
504
                      * building return element
505
505
                      */
506
 
 
507
 
 
508
 
 
 
506
                     
 
507
                     
 
508
                     
509
509
                                    /*
510
510
                                     * because elements are ordered this works fine
511
511
                                     */
512
 
 
513
 
 
 
512
                                  
 
513
                                   
514
514
                                   if(current_node != NULL && is_early_node_valid)
515
515
                                   {
516
516
                                       current_node = axiom_node_get_next_sibling(current_node, env);
517
 
 
518
 
 
 
517
                                       
 
518
                                       
519
519
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
520
520
                                        {
521
521
                                            current_node = axiom_node_get_next_sibling(current_node, env);
525
525
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
526
526
                                            qname = axiom_element_get_qname(current_element, env, current_node);
527
527
                                        }
528
 
 
 
528
                                       
529
529
                                   }
530
530
                                   is_early_node_valid = AXIS2_FALSE;
531
 
 
 
531
                                 
532
532
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
533
 
 
534
 
 
535
 
                           if (
 
533
                                 
 
534
 
 
535
                           if ( 
536
536
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
537
537
                           {
538
538
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
539
539
                              {
540
540
                                is_early_node_valid = AXIS2_TRUE;
541
541
                              }
542
 
 
543
 
 
 
542
                              
 
543
                                 
544
544
                                      text_value = axiom_element_get_text(current_element, env, current_node);
545
545
                                      if(text_value != NULL)
546
546
                                      {
555
555
                                                                      AXIS2_FALSE);
556
556
                                            }
557
557
                                      }
558
 
 
 
558
                                      
559
559
                                      else
560
560
                                      {
561
561
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
562
562
                                          status = AXIS2_FAILURE;
563
563
                                      }
564
 
 
 
564
                                      
565
565
                                 if(AXIS2_FAILURE ==  status)
566
566
                                 {
567
567
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
572
572
                                     return AXIS2_FAILURE;
573
573
                                 }
574
574
                              }
575
 
 
 
575
                           
576
576
                  if(element_qname)
577
577
                  {
578
578
                     axutil_qname_free(element_qname, env);
579
579
                     element_qname = NULL;
580
580
                  }
581
 
 
582
 
 
583
 
 
 
581
                 
 
582
 
 
583
                     
584
584
                     /*
585
585
                      * building serviceTag element
586
586
                      */
587
 
 
588
 
 
589
 
 
 
587
                     
 
588
                     
 
589
                     
590
590
                                    /*
591
591
                                     * because elements are ordered this works fine
592
592
                                     */
593
 
 
594
 
 
 
593
                                  
 
594
                                   
595
595
                                   if(current_node != NULL && is_early_node_valid)
596
596
                                   {
597
597
                                       current_node = axiom_node_get_next_sibling(current_node, env);
598
 
 
599
 
 
 
598
                                       
 
599
                                       
600
600
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
601
601
                                        {
602
602
                                            current_node = axiom_node_get_next_sibling(current_node, env);
606
606
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
607
607
                                            qname = axiom_element_get_qname(current_element, env, current_node);
608
608
                                        }
609
 
 
 
609
                                       
610
610
                                   }
611
611
                                   is_early_node_valid = AXIS2_FALSE;
612
 
 
 
612
                                 
613
613
                                 element_qname = axutil_qname_create(env, "serviceTag", "http://eucalyptus.ucsb.edu/", NULL);
614
 
 
615
 
 
616
 
                           if (
 
614
                                 
 
615
 
 
616
                           if ( 
617
617
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
618
618
                           {
619
619
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
620
620
                              {
621
621
                                is_early_node_valid = AXIS2_TRUE;
622
622
                              }
623
 
 
624
 
 
 
623
                              
 
624
                                 
625
625
                                      text_value = axiom_element_get_text(current_element, env, current_node);
626
626
                                      if(text_value != NULL)
627
627
                                      {
628
628
                                            status = adb_getLogsType_set_serviceTag(_getLogsType, env,
629
629
                                                               text_value);
630
630
                                      }
631
 
 
 
631
                                      
632
632
                                      else
633
633
                                      {
634
634
                                            /*
635
635
                                             * axis2_qname_t *qname = NULL;
636
636
                                             * axiom_attribute_t *the_attri = NULL;
637
 
                                             *
 
637
                                             * 
638
638
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
639
639
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
640
640
                                             */
652
652
                                                 axutil_hash_index_t *hi;
653
653
                                                 void *val;
654
654
                                                 const void *key;
655
 
 
656
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
655
                                        
 
656
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
657
657
                                                 {
658
658
                                                     axutil_hash_this(hi, &key, NULL, &val);
659
 
 
 
659
                                                     
660
660
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
661
661
                                                     {
662
662
                                                         the_attri = (axiom_attribute_t*)val;
687
687
                                                                   "");
688
688
                                            }
689
689
                                      }
690
 
 
 
690
                                      
691
691
                                 if(AXIS2_FAILURE ==  status)
692
692
                                 {
693
693
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for serviceTag ");
698
698
                                     return AXIS2_FAILURE;
699
699
                                 }
700
700
                              }
701
 
 
 
701
                           
702
702
                  if(element_qname)
703
703
                  {
704
704
                     axutil_qname_free(element_qname, env);
705
705
                     element_qname = NULL;
706
706
                  }
707
 
 
 
707
                 
708
708
          return status;
709
709
       }
710
710
 
711
711
          axis2_bool_t AXIS2_CALL
712
712
          adb_getLogsType_is_particle()
713
713
          {
714
 
 
 
714
            
715
715
                 return AXIS2_FALSE;
716
 
 
 
716
              
717
717
          }
718
718
 
719
719
 
723
723
                    const axutil_env_t *env, axiom_element_t *parent_element,
724
724
                    axutil_hash_t *namespaces, int *next_ns_index)
725
725
          {
726
 
 
 
726
            
727
727
                  /* Here this is an empty function, Nothing to declare */
728
 
 
 
728
                 
729
729
          }
730
730
 
731
 
 
732
 
 
 
731
        
 
732
        
733
733
        axiom_node_t* AXIS2_CALL
734
734
        adb_getLogsType_serialize(
735
735
                adb_getLogsType_t* _getLogsType,
736
736
                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)
737
737
        {
738
 
 
739
 
 
 
738
            
 
739
            
740
740
             axis2_char_t *string_to_stream;
741
 
 
742
 
 
 
741
            
 
742
         
743
743
         axiom_node_t *current_node = NULL;
744
744
         int tag_closed = 0;
745
745
 
746
 
 
747
 
 
 
746
         
 
747
         
748
748
                axiom_namespace_t *ns1 = NULL;
749
749
 
750
750
                axis2_char_t *qname_uri = NULL;
751
751
                axis2_char_t *qname_prefix = NULL;
752
752
                axis2_char_t *p_prefix = NULL;
753
753
                axis2_bool_t ns_already_defined;
754
 
 
 
754
            
755
755
                    axis2_char_t *text_value_1;
756
756
                    axis2_char_t *text_value_1_temp;
757
 
 
 
757
                    
758
758
                    axis2_char_t *text_value_2;
759
759
                    axis2_char_t *text_value_2_temp;
760
 
 
 
760
                    
761
761
                    axis2_char_t *text_value_3;
762
762
                    axis2_char_t *text_value_3_temp;
763
 
 
 
763
                    
764
764
                    axis2_char_t text_value_4[64];
765
 
 
 
765
                    
766
766
                    axis2_char_t *text_value_5;
767
767
                    axis2_char_t *text_value_5_temp;
768
 
 
 
768
                    
769
769
               axis2_char_t *start_input_str = NULL;
770
770
               axis2_char_t *end_input_str = NULL;
771
771
               unsigned int start_input_str_len = 0;
772
772
               unsigned int end_input_str_len = 0;
773
 
 
774
 
 
 
773
            
 
774
            
775
775
               axiom_data_source_t *data_source = NULL;
776
776
               axutil_stream_t *stream = NULL;
777
777
 
778
 
 
 
778
            
779
779
 
780
780
            AXIS2_ENV_CHECK(env, NULL);
781
781
            AXIS2_PARAM_CHECK(env->error, _getLogsType, NULL);
782
 
 
783
 
 
 
782
            
 
783
            
784
784
                    current_node = parent;
785
785
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
786
786
                    if (!data_source)
788
788
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
789
789
                    if (!stream)
790
790
                        return NULL;
791
 
 
 
791
                  
792
792
            if(!parent_tag_closed)
793
793
            {
794
 
 
795
 
              string_to_stream = ">";
 
794
            
 
795
              string_to_stream = ">"; 
796
796
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
797
797
              tag_closed = 1;
798
 
 
 
798
            
799
799
            }
800
 
 
 
800
            
801
801
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
802
802
                       {
803
803
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
804
804
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
805
805
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
806
 
 
 
806
                           
807
807
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
808
808
                                            "http://eucalyptus.ucsb.edu/",
809
809
                                            p_prefix));
810
810
                       }
811
 
 
 
811
                      
812
812
 
813
813
                   if (!_getLogsType->is_valid_correlationId)
814
814
                   {
815
 
 
 
815
                      
816
816
                           /* no need to complain for minoccurs=0 element */
817
 
 
818
 
 
 
817
                            
 
818
                          
819
819
                   }
820
820
                   else
821
821
                   {
822
822
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
823
 
                                 (4 + axutil_strlen(p_prefix) +
824
 
                                  axutil_strlen("correlationId")));
825
 
 
 
823
                                 (4 + axutil_strlen(p_prefix) + 
 
824
                                  axutil_strlen("correlationId"))); 
 
825
                                 
826
826
                                 /* axutil_strlen("<:>") + 1 = 4 */
827
827
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
828
828
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
829
829
                                  /* axutil_strlen("</:>") + 1 = 5 */
830
 
 
831
 
 
832
 
 
833
 
 
834
 
 
835
 
 
 
830
                                  
 
831
                     
 
832
 
 
833
                   
 
834
                   
 
835
                     
836
836
                     /*
837
837
                      * parsing correlationId element
838
838
                      */
839
839
 
840
 
 
841
 
 
 
840
                    
 
841
                    
842
842
                            sprintf(start_input_str, "<%s%scorrelationId>",
843
843
                                 p_prefix?p_prefix:"",
844
844
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
845
 
 
 
845
                            
846
846
                        start_input_str_len = axutil_strlen(start_input_str);
847
847
                        sprintf(end_input_str, "</%s%scorrelationId>",
848
848
                                 p_prefix?p_prefix:"",
849
849
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
850
850
                        end_input_str_len = axutil_strlen(end_input_str);
851
 
 
 
851
                    
852
852
                           text_value_1 = _getLogsType->property_correlationId;
853
 
 
 
853
                           
854
854
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
855
 
 
856
 
 
 
855
                           
 
856
                            
857
857
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
858
858
                           if (text_value_1_temp)
859
859
                           {
864
864
                           {
865
865
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
866
866
                           }
867
 
 
 
867
                           
868
868
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
869
 
 
870
 
 
 
869
                           
 
870
                     
871
871
                     AXIS2_FREE(env->allocator,start_input_str);
872
872
                     AXIS2_FREE(env->allocator,end_input_str);
873
 
                 }
874
 
 
875
 
 
 
873
                 } 
 
874
 
 
875
                 
876
876
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
877
877
                       {
878
878
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
879
879
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
880
880
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
881
 
 
 
881
                           
882
882
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
883
883
                                            "http://eucalyptus.ucsb.edu/",
884
884
                                            p_prefix));
885
885
                       }
886
 
 
 
886
                      
887
887
 
888
888
                   if (!_getLogsType->is_valid_userId)
889
889
                   {
890
 
 
 
890
                      
891
891
                           /* no need to complain for minoccurs=0 element */
892
 
 
893
 
 
 
892
                            
 
893
                          
894
894
                   }
895
895
                   else
896
896
                   {
897
897
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
898
 
                                 (4 + axutil_strlen(p_prefix) +
899
 
                                  axutil_strlen("userId")));
900
 
 
 
898
                                 (4 + axutil_strlen(p_prefix) + 
 
899
                                  axutil_strlen("userId"))); 
 
900
                                 
901
901
                                 /* axutil_strlen("<:>") + 1 = 4 */
902
902
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
903
903
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
904
904
                                  /* axutil_strlen("</:>") + 1 = 5 */
905
 
 
906
 
 
907
 
 
908
 
 
909
 
 
910
 
 
 
905
                                  
 
906
                     
 
907
 
 
908
                   
 
909
                   
 
910
                     
911
911
                     /*
912
912
                      * parsing userId element
913
913
                      */
914
914
 
915
 
 
916
 
 
 
915
                    
 
916
                    
917
917
                            sprintf(start_input_str, "<%s%suserId>",
918
918
                                 p_prefix?p_prefix:"",
919
919
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
920
 
 
 
920
                            
921
921
                        start_input_str_len = axutil_strlen(start_input_str);
922
922
                        sprintf(end_input_str, "</%s%suserId>",
923
923
                                 p_prefix?p_prefix:"",
924
924
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
925
925
                        end_input_str_len = axutil_strlen(end_input_str);
926
 
 
 
926
                    
927
927
                           text_value_2 = _getLogsType->property_userId;
928
 
 
 
928
                           
929
929
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
930
 
 
931
 
 
 
930
                           
 
931
                            
932
932
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
933
933
                           if (text_value_2_temp)
934
934
                           {
939
939
                           {
940
940
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
941
941
                           }
942
 
 
 
942
                           
943
943
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
944
 
 
945
 
 
 
944
                           
 
945
                     
946
946
                     AXIS2_FREE(env->allocator,start_input_str);
947
947
                     AXIS2_FREE(env->allocator,end_input_str);
948
 
                 }
949
 
 
950
 
 
 
948
                 } 
 
949
 
 
950
                 
951
951
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
952
952
                       {
953
953
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
954
954
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
955
955
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
956
 
 
 
956
                           
957
957
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
958
958
                                            "http://eucalyptus.ucsb.edu/",
959
959
                                            p_prefix));
960
960
                       }
961
 
 
 
961
                      
962
962
 
963
963
                   if (!_getLogsType->is_valid_statusMessage)
964
964
                   {
965
 
 
 
965
                      
966
966
                           /* no need to complain for minoccurs=0 element */
967
 
 
968
 
 
 
967
                            
 
968
                          
969
969
                   }
970
970
                   else
971
971
                   {
972
972
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
973
 
                                 (4 + axutil_strlen(p_prefix) +
974
 
                                  axutil_strlen("statusMessage")));
975
 
 
 
973
                                 (4 + axutil_strlen(p_prefix) + 
 
974
                                  axutil_strlen("statusMessage"))); 
 
975
                                 
976
976
                                 /* axutil_strlen("<:>") + 1 = 4 */
977
977
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
978
978
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
979
979
                                  /* axutil_strlen("</:>") + 1 = 5 */
980
 
 
981
 
 
982
 
 
983
 
 
984
 
 
985
 
 
 
980
                                  
 
981
                     
 
982
 
 
983
                   
 
984
                   
 
985
                     
986
986
                     /*
987
987
                      * parsing statusMessage element
988
988
                      */
989
989
 
990
 
 
991
 
 
 
990
                    
 
991
                    
992
992
                            sprintf(start_input_str, "<%s%sstatusMessage>",
993
993
                                 p_prefix?p_prefix:"",
994
994
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
995
 
 
 
995
                            
996
996
                        start_input_str_len = axutil_strlen(start_input_str);
997
997
                        sprintf(end_input_str, "</%s%sstatusMessage>",
998
998
                                 p_prefix?p_prefix:"",
999
999
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1000
1000
                        end_input_str_len = axutil_strlen(end_input_str);
1001
 
 
 
1001
                    
1002
1002
                           text_value_3 = _getLogsType->property_statusMessage;
1003
 
 
 
1003
                           
1004
1004
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1005
 
 
1006
 
 
 
1005
                           
 
1006
                            
1007
1007
                           text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1008
1008
                           if (text_value_3_temp)
1009
1009
                           {
1014
1014
                           {
1015
1015
                               axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1016
1016
                           }
1017
 
 
 
1017
                           
1018
1018
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1019
 
 
1020
 
 
 
1019
                           
 
1020
                     
1021
1021
                     AXIS2_FREE(env->allocator,start_input_str);
1022
1022
                     AXIS2_FREE(env->allocator,end_input_str);
1023
 
                 }
1024
 
 
1025
 
 
 
1023
                 } 
 
1024
 
 
1025
                 
1026
1026
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1027
1027
                       {
1028
1028
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1029
1029
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1030
1030
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1031
 
 
 
1031
                           
1032
1032
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1033
1033
                                            "http://eucalyptus.ucsb.edu/",
1034
1034
                                            p_prefix));
1035
1035
                       }
1036
 
 
 
1036
                      
1037
1037
 
1038
1038
                   if (!_getLogsType->is_valid_return)
1039
1039
                   {
1040
 
 
 
1040
                      
1041
1041
                           /* no need to complain for minoccurs=0 element */
1042
 
 
1043
 
 
 
1042
                            
 
1043
                          
1044
1044
                   }
1045
1045
                   else
1046
1046
                   {
1047
1047
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1048
 
                                 (4 + axutil_strlen(p_prefix) +
1049
 
                                  axutil_strlen("return")));
1050
 
 
 
1048
                                 (4 + axutil_strlen(p_prefix) + 
 
1049
                                  axutil_strlen("return"))); 
 
1050
                                 
1051
1051
                                 /* axutil_strlen("<:>") + 1 = 4 */
1052
1052
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1053
1053
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1054
1054
                                  /* axutil_strlen("</:>") + 1 = 5 */
1055
 
 
1056
 
 
1057
 
 
1058
 
 
1059
 
 
1060
 
 
 
1055
                                  
 
1056
                     
 
1057
 
 
1058
                   
 
1059
                   
 
1060
                     
1061
1061
                     /*
1062
1062
                      * parsing return element
1063
1063
                      */
1064
1064
 
1065
 
 
1066
 
 
 
1065
                    
 
1066
                    
1067
1067
                            sprintf(start_input_str, "<%s%sreturn>",
1068
1068
                                 p_prefix?p_prefix:"",
1069
1069
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1070
 
 
 
1070
                            
1071
1071
                        start_input_str_len = axutil_strlen(start_input_str);
1072
1072
                        sprintf(end_input_str, "</%s%sreturn>",
1073
1073
                                 p_prefix?p_prefix:"",
1074
1074
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1075
1075
                        end_input_str_len = axutil_strlen(end_input_str);
1076
 
 
 
1076
                    
1077
1077
                           strcpy(text_value_4, (_getLogsType->property_return)?"true":"false");
1078
 
 
 
1078
                           
1079
1079
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1080
 
 
 
1080
                           
1081
1081
                           axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1082
 
 
 
1082
                           
1083
1083
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1084
 
 
1085
 
 
 
1084
                           
 
1085
                     
1086
1086
                     AXIS2_FREE(env->allocator,start_input_str);
1087
1087
                     AXIS2_FREE(env->allocator,end_input_str);
1088
 
                 }
1089
 
 
1090
 
 
 
1088
                 } 
 
1089
 
 
1090
                 
1091
1091
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1092
1092
                       {
1093
1093
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1094
1094
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1095
1095
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1096
 
 
 
1096
                           
1097
1097
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1098
1098
                                            "http://eucalyptus.ucsb.edu/",
1099
1099
                                            p_prefix));
1100
1100
                       }
1101
 
 
 
1101
                      
1102
1102
 
1103
1103
                   if (!_getLogsType->is_valid_serviceTag)
1104
1104
                   {
1105
 
 
 
1105
                      
1106
1106
                           /* no need to complain for minoccurs=0 element */
1107
 
 
1108
 
 
 
1107
                            
 
1108
                          
1109
1109
                   }
1110
1110
                   else
1111
1111
                   {
1112
1112
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1113
 
                                 (4 + axutil_strlen(p_prefix) +
1114
 
                                  axutil_strlen("serviceTag")));
1115
 
 
 
1113
                                 (4 + axutil_strlen(p_prefix) + 
 
1114
                                  axutil_strlen("serviceTag"))); 
 
1115
                                 
1116
1116
                                 /* axutil_strlen("<:>") + 1 = 4 */
1117
1117
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1118
1118
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("serviceTag")));
1119
1119
                                  /* axutil_strlen("</:>") + 1 = 5 */
1120
 
 
1121
 
 
1122
 
 
1123
 
 
1124
 
 
1125
 
 
 
1120
                                  
 
1121
                     
 
1122
 
 
1123
                   
 
1124
                   
 
1125
                     
1126
1126
                     /*
1127
1127
                      * parsing serviceTag element
1128
1128
                      */
1129
1129
 
1130
 
 
1131
 
 
 
1130
                    
 
1131
                    
1132
1132
                            sprintf(start_input_str, "<%s%sserviceTag>",
1133
1133
                                 p_prefix?p_prefix:"",
1134
1134
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1135
 
 
 
1135
                            
1136
1136
                        start_input_str_len = axutil_strlen(start_input_str);
1137
1137
                        sprintf(end_input_str, "</%s%sserviceTag>",
1138
1138
                                 p_prefix?p_prefix:"",
1139
1139
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1140
1140
                        end_input_str_len = axutil_strlen(end_input_str);
1141
 
 
 
1141
                    
1142
1142
                           text_value_5 = _getLogsType->property_serviceTag;
1143
 
 
 
1143
                           
1144
1144
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1145
 
 
1146
 
 
 
1145
                           
 
1146
                            
1147
1147
                           text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1148
1148
                           if (text_value_5_temp)
1149
1149
                           {
1154
1154
                           {
1155
1155
                               axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1156
1156
                           }
1157
 
 
 
1157
                           
1158
1158
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1159
 
 
1160
 
 
 
1159
                           
 
1160
                     
1161
1161
                     AXIS2_FREE(env->allocator,start_input_str);
1162
1162
                     AXIS2_FREE(env->allocator,end_input_str);
1163
 
                 }
1164
 
 
1165
 
 
 
1163
                 } 
 
1164
 
 
1165
                 
1166
1166
 
1167
1167
            return parent;
1168
1168
        }
1169
1169
 
1170
1170
 
1171
 
 
 
1171
        
1172
1172
 
1173
1173
            /**
1174
1174
             * getter for correlationId.
1178
1178
                    adb_getLogsType_t* _getLogsType,
1179
1179
                    const axutil_env_t *env)
1180
1180
             {
1181
 
 
 
1181
                
1182
1182
                    AXIS2_ENV_CHECK(env, NULL);
1183
1183
                    AXIS2_PARAM_CHECK(env->error, _getLogsType, NULL);
1184
 
 
 
1184
                  
1185
1185
 
1186
1186
                return _getLogsType->property_correlationId;
1187
1187
             }
1195
1195
                    const axutil_env_t *env,
1196
1196
                    const axis2_char_t*  arg_correlationId)
1197
1197
             {
1198
 
 
 
1198
                
1199
1199
 
1200
1200
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1201
1201
                AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1202
 
 
 
1202
                
1203
1203
                if(_getLogsType->is_valid_correlationId &&
1204
1204
                        arg_correlationId == _getLogsType->property_correlationId)
1205
1205
                {
1206
 
 
1207
 
                    return AXIS2_SUCCESS;
 
1206
                    
 
1207
                    return AXIS2_SUCCESS; 
1208
1208
                }
1209
1209
 
1210
1210
                adb_getLogsType_reset_correlationId(_getLogsType, env);
1211
1211
 
1212
 
 
 
1212
                
1213
1213
                if(NULL == arg_correlationId)
1214
1214
                {
1215
1215
                    /* We are already done */
1222
1222
                            return AXIS2_FAILURE;
1223
1223
                        }
1224
1224
                        _getLogsType->is_valid_correlationId = AXIS2_TRUE;
1225
 
 
 
1225
                    
1226
1226
                return AXIS2_SUCCESS;
1227
1227
             }
1228
1228
 
1229
 
 
 
1229
             
1230
1230
 
1231
1231
           /**
1232
1232
            * resetter for correlationId
1242
1242
 
1243
1243
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1244
1244
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1245
 
 
1246
 
 
1247
 
 
1248
 
 
1249
 
 
 
1245
               
 
1246
 
 
1247
               
 
1248
            
 
1249
                
1250
1250
                if(_getLogsType->property_correlationId != NULL)
1251
1251
                {
1252
 
 
1253
 
 
 
1252
                   
 
1253
                   
1254
1254
                        AXIS2_FREE(env-> allocator, _getLogsType->property_correlationId);
1255
1255
                     _getLogsType->property_correlationId = NULL;
1256
1256
                }
1257
 
 
1258
 
 
1259
 
 
1260
 
                _getLogsType->is_valid_correlationId = AXIS2_FALSE;
 
1257
            
 
1258
                
 
1259
                
 
1260
                _getLogsType->is_valid_correlationId = AXIS2_FALSE; 
1261
1261
               return AXIS2_SUCCESS;
1262
1262
           }
1263
1263
 
1271
1271
           {
1272
1272
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1273
1273
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_TRUE);
1274
 
 
 
1274
               
1275
1275
               return !_getLogsType->is_valid_correlationId;
1276
1276
           }
1277
1277
 
1286
1286
               return adb_getLogsType_reset_correlationId(_getLogsType, env);
1287
1287
           }
1288
1288
 
1289
 
 
 
1289
           
1290
1290
 
1291
1291
            /**
1292
1292
             * getter for userId.
1296
1296
                    adb_getLogsType_t* _getLogsType,
1297
1297
                    const axutil_env_t *env)
1298
1298
             {
1299
 
 
 
1299
                
1300
1300
                    AXIS2_ENV_CHECK(env, NULL);
1301
1301
                    AXIS2_PARAM_CHECK(env->error, _getLogsType, NULL);
1302
 
 
 
1302
                  
1303
1303
 
1304
1304
                return _getLogsType->property_userId;
1305
1305
             }
1313
1313
                    const axutil_env_t *env,
1314
1314
                    const axis2_char_t*  arg_userId)
1315
1315
             {
1316
 
 
 
1316
                
1317
1317
 
1318
1318
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1319
1319
                AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1320
 
 
 
1320
                
1321
1321
                if(_getLogsType->is_valid_userId &&
1322
1322
                        arg_userId == _getLogsType->property_userId)
1323
1323
                {
1324
 
 
1325
 
                    return AXIS2_SUCCESS;
 
1324
                    
 
1325
                    return AXIS2_SUCCESS; 
1326
1326
                }
1327
1327
 
1328
1328
                adb_getLogsType_reset_userId(_getLogsType, env);
1329
1329
 
1330
 
 
 
1330
                
1331
1331
                if(NULL == arg_userId)
1332
1332
                {
1333
1333
                    /* We are already done */
1340
1340
                            return AXIS2_FAILURE;
1341
1341
                        }
1342
1342
                        _getLogsType->is_valid_userId = AXIS2_TRUE;
1343
 
 
 
1343
                    
1344
1344
                return AXIS2_SUCCESS;
1345
1345
             }
1346
1346
 
1347
 
 
 
1347
             
1348
1348
 
1349
1349
           /**
1350
1350
            * resetter for userId
1360
1360
 
1361
1361
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1362
1362
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1363
 
 
1364
 
 
1365
 
 
1366
 
 
1367
 
 
 
1363
               
 
1364
 
 
1365
               
 
1366
            
 
1367
                
1368
1368
                if(_getLogsType->property_userId != NULL)
1369
1369
                {
1370
 
 
1371
 
 
 
1370
                   
 
1371
                   
1372
1372
                        AXIS2_FREE(env-> allocator, _getLogsType->property_userId);
1373
1373
                     _getLogsType->property_userId = NULL;
1374
1374
                }
1375
 
 
1376
 
 
1377
 
 
1378
 
                _getLogsType->is_valid_userId = AXIS2_FALSE;
 
1375
            
 
1376
                
 
1377
                
 
1378
                _getLogsType->is_valid_userId = AXIS2_FALSE; 
1379
1379
               return AXIS2_SUCCESS;
1380
1380
           }
1381
1381
 
1389
1389
           {
1390
1390
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1391
1391
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_TRUE);
1392
 
 
 
1392
               
1393
1393
               return !_getLogsType->is_valid_userId;
1394
1394
           }
1395
1395
 
1404
1404
               return adb_getLogsType_reset_userId(_getLogsType, env);
1405
1405
           }
1406
1406
 
1407
 
 
 
1407
           
1408
1408
 
1409
1409
            /**
1410
1410
             * getter for statusMessage.
1414
1414
                    adb_getLogsType_t* _getLogsType,
1415
1415
                    const axutil_env_t *env)
1416
1416
             {
1417
 
 
 
1417
                
1418
1418
                    AXIS2_ENV_CHECK(env, NULL);
1419
1419
                    AXIS2_PARAM_CHECK(env->error, _getLogsType, NULL);
1420
 
 
 
1420
                  
1421
1421
 
1422
1422
                return _getLogsType->property_statusMessage;
1423
1423
             }
1431
1431
                    const axutil_env_t *env,
1432
1432
                    const axis2_char_t*  arg_statusMessage)
1433
1433
             {
1434
 
 
 
1434
                
1435
1435
 
1436
1436
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1437
1437
                AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1438
 
 
 
1438
                
1439
1439
                if(_getLogsType->is_valid_statusMessage &&
1440
1440
                        arg_statusMessage == _getLogsType->property_statusMessage)
1441
1441
                {
1442
 
 
1443
 
                    return AXIS2_SUCCESS;
 
1442
                    
 
1443
                    return AXIS2_SUCCESS; 
1444
1444
                }
1445
1445
 
1446
1446
                adb_getLogsType_reset_statusMessage(_getLogsType, env);
1447
1447
 
1448
 
 
 
1448
                
1449
1449
                if(NULL == arg_statusMessage)
1450
1450
                {
1451
1451
                    /* We are already done */
1458
1458
                            return AXIS2_FAILURE;
1459
1459
                        }
1460
1460
                        _getLogsType->is_valid_statusMessage = AXIS2_TRUE;
1461
 
 
 
1461
                    
1462
1462
                return AXIS2_SUCCESS;
1463
1463
             }
1464
1464
 
1465
 
 
 
1465
             
1466
1466
 
1467
1467
           /**
1468
1468
            * resetter for statusMessage
1478
1478
 
1479
1479
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1480
1480
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1481
 
 
1482
 
 
1483
 
 
1484
 
 
1485
 
 
 
1481
               
 
1482
 
 
1483
               
 
1484
            
 
1485
                
1486
1486
                if(_getLogsType->property_statusMessage != NULL)
1487
1487
                {
1488
 
 
1489
 
 
 
1488
                   
 
1489
                   
1490
1490
                        AXIS2_FREE(env-> allocator, _getLogsType->property_statusMessage);
1491
1491
                     _getLogsType->property_statusMessage = NULL;
1492
1492
                }
1493
 
 
1494
 
 
1495
 
 
1496
 
                _getLogsType->is_valid_statusMessage = AXIS2_FALSE;
 
1493
            
 
1494
                
 
1495
                
 
1496
                _getLogsType->is_valid_statusMessage = AXIS2_FALSE; 
1497
1497
               return AXIS2_SUCCESS;
1498
1498
           }
1499
1499
 
1507
1507
           {
1508
1508
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1509
1509
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_TRUE);
1510
 
 
 
1510
               
1511
1511
               return !_getLogsType->is_valid_statusMessage;
1512
1512
           }
1513
1513
 
1522
1522
               return adb_getLogsType_reset_statusMessage(_getLogsType, env);
1523
1523
           }
1524
1524
 
1525
 
 
 
1525
           
1526
1526
 
1527
1527
            /**
1528
1528
             * getter for return.
1532
1532
                    adb_getLogsType_t* _getLogsType,
1533
1533
                    const axutil_env_t *env)
1534
1534
             {
1535
 
 
 
1535
                
1536
1536
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1537
1537
                    AXIS2_PARAM_CHECK(env->error, _getLogsType, (axis2_bool_t)0);
1538
 
 
 
1538
                  
1539
1539
 
1540
1540
                return _getLogsType->property_return;
1541
1541
             }
1549
1549
                    const axutil_env_t *env,
1550
1550
                    axis2_bool_t  arg_return)
1551
1551
             {
1552
 
 
 
1552
                
1553
1553
 
1554
1554
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1555
1555
                AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1556
 
 
 
1556
                
1557
1557
                if(_getLogsType->is_valid_return &&
1558
1558
                        arg_return == _getLogsType->property_return)
1559
1559
                {
1560
 
 
1561
 
                    return AXIS2_SUCCESS;
 
1560
                    
 
1561
                    return AXIS2_SUCCESS; 
1562
1562
                }
1563
1563
 
1564
1564
                adb_getLogsType_reset_return(_getLogsType, env);
1565
1565
 
1566
1566
                _getLogsType->property_return = arg_return;
1567
1567
                        _getLogsType->is_valid_return = AXIS2_TRUE;
1568
 
 
 
1568
                    
1569
1569
                return AXIS2_SUCCESS;
1570
1570
             }
1571
1571
 
1572
 
 
 
1572
             
1573
1573
 
1574
1574
           /**
1575
1575
            * resetter for return
1585
1585
 
1586
1586
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1587
1587
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1588
 
 
1589
 
 
1590
 
               _getLogsType->is_valid_return = AXIS2_FALSE;
 
1588
               
 
1589
 
 
1590
               _getLogsType->is_valid_return = AXIS2_FALSE; 
1591
1591
               return AXIS2_SUCCESS;
1592
1592
           }
1593
1593
 
1601
1601
           {
1602
1602
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1603
1603
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_TRUE);
1604
 
 
 
1604
               
1605
1605
               return !_getLogsType->is_valid_return;
1606
1606
           }
1607
1607
 
1616
1616
               return adb_getLogsType_reset_return(_getLogsType, env);
1617
1617
           }
1618
1618
 
1619
 
 
 
1619
           
1620
1620
 
1621
1621
            /**
1622
1622
             * getter for serviceTag.
1626
1626
                    adb_getLogsType_t* _getLogsType,
1627
1627
                    const axutil_env_t *env)
1628
1628
             {
1629
 
 
 
1629
                
1630
1630
                    AXIS2_ENV_CHECK(env, NULL);
1631
1631
                    AXIS2_PARAM_CHECK(env->error, _getLogsType, NULL);
1632
 
 
 
1632
                  
1633
1633
 
1634
1634
                return _getLogsType->property_serviceTag;
1635
1635
             }
1643
1643
                    const axutil_env_t *env,
1644
1644
                    const axis2_char_t*  arg_serviceTag)
1645
1645
             {
1646
 
 
 
1646
                
1647
1647
 
1648
1648
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1649
1649
                AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1650
 
 
 
1650
                
1651
1651
                if(_getLogsType->is_valid_serviceTag &&
1652
1652
                        arg_serviceTag == _getLogsType->property_serviceTag)
1653
1653
                {
1654
 
 
1655
 
                    return AXIS2_SUCCESS;
 
1654
                    
 
1655
                    return AXIS2_SUCCESS; 
1656
1656
                }
1657
1657
 
1658
1658
                adb_getLogsType_reset_serviceTag(_getLogsType, env);
1659
1659
 
1660
 
 
 
1660
                
1661
1661
                if(NULL == arg_serviceTag)
1662
1662
                {
1663
1663
                    /* We are already done */
1670
1670
                            return AXIS2_FAILURE;
1671
1671
                        }
1672
1672
                        _getLogsType->is_valid_serviceTag = AXIS2_TRUE;
1673
 
 
 
1673
                    
1674
1674
                return AXIS2_SUCCESS;
1675
1675
             }
1676
1676
 
1677
 
 
 
1677
             
1678
1678
 
1679
1679
           /**
1680
1680
            * resetter for serviceTag
1690
1690
 
1691
1691
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1692
1692
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_FAILURE);
1693
 
 
1694
 
 
1695
 
 
1696
 
 
1697
 
 
 
1693
               
 
1694
 
 
1695
               
 
1696
            
 
1697
                
1698
1698
                if(_getLogsType->property_serviceTag != NULL)
1699
1699
                {
1700
 
 
1701
 
 
 
1700
                   
 
1701
                   
1702
1702
                        AXIS2_FREE(env-> allocator, _getLogsType->property_serviceTag);
1703
1703
                     _getLogsType->property_serviceTag = NULL;
1704
1704
                }
1705
 
 
1706
 
 
1707
 
 
1708
 
                _getLogsType->is_valid_serviceTag = AXIS2_FALSE;
 
1705
            
 
1706
                
 
1707
                
 
1708
                _getLogsType->is_valid_serviceTag = AXIS2_FALSE; 
1709
1709
               return AXIS2_SUCCESS;
1710
1710
           }
1711
1711
 
1719
1719
           {
1720
1720
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1721
1721
               AXIS2_PARAM_CHECK(env->error, _getLogsType, AXIS2_TRUE);
1722
 
 
 
1722
               
1723
1723
               return !_getLogsType->is_valid_serviceTag;
1724
1724
           }
1725
1725
 
1734
1734
               return adb_getLogsType_reset_serviceTag(_getLogsType, env);
1735
1735
           }
1736
1736
 
1737
 
 
 
1737
           
1738
1738