← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cluster/generated/adb_unassignAddressType.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
cluster/generated/adb_unassignAddressType.c
8
8
         */
9
9
 
10
10
        #include "adb_unassignAddressType.h"
11
 
 
 
11
        
12
12
                /*
13
13
                 * This type was generated from the piece of schema that had
14
14
                 * name = unassignAddressType
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_unassignAddressType
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_source;
48
48
 
49
 
 
 
49
                
50
50
                axis2_bool_t is_valid_source;
51
51
 
52
52
 
53
53
            axis2_char_t* property_dest;
54
54
 
55
 
 
 
55
                
56
56
                axis2_bool_t is_valid_dest;
57
57
 
58
58
 
59
 
 
 
59
            
60
60
        };
61
61
 
62
62
 
63
63
       /************************* Private Function prototypes ********************************/
64
 
 
 
64
        
65
65
 
66
66
                axis2_status_t AXIS2_CALL
67
67
                adb_unassignAddressType_set_correlationId_nil(
68
68
                        adb_unassignAddressType_t* _unassignAddressType,
69
69
                        const axutil_env_t *env);
70
 
 
 
70
            
71
71
 
72
72
                axis2_status_t AXIS2_CALL
73
73
                adb_unassignAddressType_set_userId_nil(
74
74
                        adb_unassignAddressType_t* _unassignAddressType,
75
75
                        const axutil_env_t *env);
76
 
 
 
76
            
77
77
 
78
78
                axis2_status_t AXIS2_CALL
79
79
                adb_unassignAddressType_set_return_nil(
80
80
                        adb_unassignAddressType_t* _unassignAddressType,
81
81
                        const axutil_env_t *env);
82
 
 
 
82
            
83
83
 
84
84
                axis2_status_t AXIS2_CALL
85
85
                adb_unassignAddressType_set_source_nil(
86
86
                        adb_unassignAddressType_t* _unassignAddressType,
87
87
                        const axutil_env_t *env);
88
 
 
 
88
            
89
89
 
90
90
                axis2_status_t AXIS2_CALL
91
91
                adb_unassignAddressType_set_dest_nil(
92
92
                        adb_unassignAddressType_t* _unassignAddressType,
93
93
                        const axutil_env_t *env);
94
 
 
 
94
            
95
95
 
96
96
 
97
97
       /************************* Function Implmentations ********************************/
100
100
            const axutil_env_t *env)
101
101
        {
102
102
            adb_unassignAddressType_t *_unassignAddressType = NULL;
103
 
 
 
103
            
104
104
            AXIS2_ENV_CHECK(env, NULL);
105
105
 
106
106
            _unassignAddressType = (adb_unassignAddressType_t *) AXIS2_MALLOC(env->
125
125
                  _unassignAddressType->is_valid_source  = AXIS2_FALSE;
126
126
            _unassignAddressType->property_dest  = NULL;
127
127
                  _unassignAddressType->is_valid_dest  = AXIS2_FALSE;
128
 
 
 
128
            
129
129
 
130
130
            return _unassignAddressType;
131
131
        }
135
135
                adb_unassignAddressType_t* _unassignAddressType,
136
136
                const axutil_env_t *env)
137
137
        {
138
 
 
 
138
            
139
139
 
140
140
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
141
141
            AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
146
146
            adb_unassignAddressType_reset_return(_unassignAddressType, env);
147
147
            adb_unassignAddressType_reset_source(_unassignAddressType, env);
148
148
            adb_unassignAddressType_reset_dest(_unassignAddressType, env);
149
 
 
 
149
            
150
150
 
151
151
            if(_unassignAddressType)
152
152
            {
157
157
        }
158
158
 
159
159
 
160
 
 
 
160
        
161
161
 
162
162
        axis2_status_t AXIS2_CALL
163
163
        adb_unassignAddressType_deserialize(
168
168
                axis2_bool_t dont_care_minoccurs)
169
169
        {
170
170
          axiom_node_t *parent = *dp_parent;
171
 
 
 
171
          
172
172
          axis2_status_t status = AXIS2_SUCCESS;
173
 
 
 
173
           
174
174
             axis2_char_t* text_value = NULL;
175
175
             axutil_qname_t *qname = NULL;
176
 
 
177
 
            axutil_qname_t *element_qname = NULL;
178
 
 
 
176
          
 
177
            axutil_qname_t *element_qname = NULL; 
 
178
            
179
179
               axiom_node_t *first_node = NULL;
180
180
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
181
181
               axiom_node_t *current_node = NULL;
182
182
               axiom_element_t *current_element = NULL;
183
 
 
 
183
            
184
184
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
185
185
            AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
186
186
 
187
 
 
188
 
 
 
187
            
 
188
              
189
189
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
190
190
              {
191
191
                  parent = axiom_node_get_next_sibling(parent, env);
193
193
              if (NULL == parent)
194
194
              {
195
195
                /* This should be checked before everything */
196
 
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
 
196
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
197
197
                            "Failed in building adb object for unassignAddressType : "
198
198
                            "NULL elemenet can not be passed to deserialize");
199
199
                return AXIS2_FAILURE;
200
200
              }
201
 
 
202
 
 
 
201
              
 
202
                      
203
203
                      first_node = axiom_node_get_first_child(parent, env);
204
 
 
205
 
 
206
 
 
207
 
 
 
204
                      
 
205
                    
 
206
 
 
207
                     
208
208
                     /*
209
209
                      * building correlationId element
210
210
                      */
211
 
 
212
 
 
213
 
 
 
211
                     
 
212
                     
 
213
                     
214
214
                                   current_node = first_node;
215
215
                                   is_early_node_valid = AXIS2_FALSE;
216
 
 
217
 
 
 
216
                                   
 
217
                                   
218
218
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
219
219
                                    {
220
220
                                        current_node = axiom_node_get_next_sibling(current_node, env);
224
224
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
225
225
                                        qname = axiom_element_get_qname(current_element, env, current_node);
226
226
                                    }
227
 
 
 
227
                                   
228
228
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
229
 
 
230
 
 
231
 
                           if (
 
229
                                 
 
230
 
 
231
                           if ( 
232
232
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
233
233
                           {
234
234
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
235
235
                              {
236
236
                                is_early_node_valid = AXIS2_TRUE;
237
237
                              }
238
 
 
239
 
 
 
238
                              
 
239
                                 
240
240
                                      text_value = axiom_element_get_text(current_element, env, current_node);
241
241
                                      if(text_value != NULL)
242
242
                                      {
243
243
                                            status = adb_unassignAddressType_set_correlationId(_unassignAddressType, env,
244
244
                                                               text_value);
245
245
                                      }
246
 
 
 
246
                                      
247
247
                                      else
248
248
                                      {
249
249
                                            /*
250
250
                                             * axis2_qname_t *qname = NULL;
251
251
                                             * axiom_attribute_t *the_attri = NULL;
252
 
                                             *
 
252
                                             * 
253
253
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
254
254
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
255
255
                                             */
267
267
                                                 axutil_hash_index_t *hi;
268
268
                                                 void *val;
269
269
                                                 const void *key;
270
 
 
271
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
270
                                        
 
271
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
272
272
                                                 {
273
273
                                                     axutil_hash_this(hi, &key, NULL, &val);
274
 
 
 
274
                                                     
275
275
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
276
276
                                                     {
277
277
                                                         the_attri = (axiom_attribute_t*)val;
302
302
                                                                   "");
303
303
                                            }
304
304
                                      }
305
 
 
 
305
                                      
306
306
                                 if(AXIS2_FAILURE ==  status)
307
307
                                 {
308
308
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
313
313
                                     return AXIS2_FAILURE;
314
314
                                 }
315
315
                              }
316
 
 
 
316
                           
317
317
                  if(element_qname)
318
318
                  {
319
319
                     axutil_qname_free(element_qname, env);
320
320
                     element_qname = NULL;
321
321
                  }
322
 
 
323
 
 
324
 
 
 
322
                 
 
323
 
 
324
                     
325
325
                     /*
326
326
                      * building userId element
327
327
                      */
328
 
 
329
 
 
330
 
 
 
328
                     
 
329
                     
 
330
                     
331
331
                                    /*
332
332
                                     * because elements are ordered this works fine
333
333
                                     */
334
 
 
335
 
 
 
334
                                  
 
335
                                   
336
336
                                   if(current_node != NULL && is_early_node_valid)
337
337
                                   {
338
338
                                       current_node = axiom_node_get_next_sibling(current_node, env);
339
 
 
340
 
 
 
339
                                       
 
340
                                       
341
341
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
342
342
                                        {
343
343
                                            current_node = axiom_node_get_next_sibling(current_node, env);
347
347
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
348
348
                                            qname = axiom_element_get_qname(current_element, env, current_node);
349
349
                                        }
350
 
 
 
350
                                       
351
351
                                   }
352
352
                                   is_early_node_valid = AXIS2_FALSE;
353
 
 
 
353
                                 
354
354
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
355
 
 
356
 
 
357
 
                           if (
 
355
                                 
 
356
 
 
357
                           if ( 
358
358
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
359
359
                           {
360
360
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
361
361
                              {
362
362
                                is_early_node_valid = AXIS2_TRUE;
363
363
                              }
364
 
 
365
 
 
 
364
                              
 
365
                                 
366
366
                                      text_value = axiom_element_get_text(current_element, env, current_node);
367
367
                                      if(text_value != NULL)
368
368
                                      {
369
369
                                            status = adb_unassignAddressType_set_userId(_unassignAddressType, env,
370
370
                                                               text_value);
371
371
                                      }
372
 
 
 
372
                                      
373
373
                                      else
374
374
                                      {
375
375
                                            /*
376
376
                                             * axis2_qname_t *qname = NULL;
377
377
                                             * axiom_attribute_t *the_attri = NULL;
378
 
                                             *
 
378
                                             * 
379
379
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
380
380
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
381
381
                                             */
393
393
                                                 axutil_hash_index_t *hi;
394
394
                                                 void *val;
395
395
                                                 const void *key;
396
 
 
397
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
396
                                        
 
397
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
398
398
                                                 {
399
399
                                                     axutil_hash_this(hi, &key, NULL, &val);
400
 
 
 
400
                                                     
401
401
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
402
402
                                                     {
403
403
                                                         the_attri = (axiom_attribute_t*)val;
428
428
                                                                   "");
429
429
                                            }
430
430
                                      }
431
 
 
 
431
                                      
432
432
                                 if(AXIS2_FAILURE ==  status)
433
433
                                 {
434
434
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
439
439
                                     return AXIS2_FAILURE;
440
440
                                 }
441
441
                              }
442
 
 
 
442
                           
443
443
                  if(element_qname)
444
444
                  {
445
445
                     axutil_qname_free(element_qname, env);
446
446
                     element_qname = NULL;
447
447
                  }
448
 
 
449
 
 
450
 
 
 
448
                 
 
449
 
 
450
                     
451
451
                     /*
452
452
                      * building statusMessage element
453
453
                      */
454
 
 
455
 
 
456
 
 
 
454
                     
 
455
                     
 
456
                     
457
457
                                    /*
458
458
                                     * because elements are ordered this works fine
459
459
                                     */
460
 
 
461
 
 
 
460
                                  
 
461
                                   
462
462
                                   if(current_node != NULL && is_early_node_valid)
463
463
                                   {
464
464
                                       current_node = axiom_node_get_next_sibling(current_node, env);
465
 
 
466
 
 
 
465
                                       
 
466
                                       
467
467
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
468
468
                                        {
469
469
                                            current_node = axiom_node_get_next_sibling(current_node, env);
473
473
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
474
474
                                            qname = axiom_element_get_qname(current_element, env, current_node);
475
475
                                        }
476
 
 
 
476
                                       
477
477
                                   }
478
478
                                   is_early_node_valid = AXIS2_FALSE;
479
 
 
 
479
                                 
480
480
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
481
 
 
482
 
 
483
 
                           if (
 
481
                                 
 
482
 
 
483
                           if ( 
484
484
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
485
485
                           {
486
486
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
487
487
                              {
488
488
                                is_early_node_valid = AXIS2_TRUE;
489
489
                              }
490
 
 
491
 
 
 
490
                              
 
491
                                 
492
492
                                      text_value = axiom_element_get_text(current_element, env, current_node);
493
493
                                      if(text_value != NULL)
494
494
                                      {
495
495
                                            status = adb_unassignAddressType_set_statusMessage(_unassignAddressType, env,
496
496
                                                               text_value);
497
497
                                      }
498
 
 
 
498
                                      
499
499
                                 if(AXIS2_FAILURE ==  status)
500
500
                                 {
501
501
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
506
506
                                     return AXIS2_FAILURE;
507
507
                                 }
508
508
                              }
509
 
 
 
509
                           
510
510
                  if(element_qname)
511
511
                  {
512
512
                     axutil_qname_free(element_qname, env);
513
513
                     element_qname = NULL;
514
514
                  }
515
 
 
516
 
 
517
 
 
 
515
                 
 
516
 
 
517
                     
518
518
                     /*
519
519
                      * building return element
520
520
                      */
521
 
 
522
 
 
523
 
 
 
521
                     
 
522
                     
 
523
                     
524
524
                                    /*
525
525
                                     * because elements are ordered this works fine
526
526
                                     */
527
 
 
528
 
 
 
527
                                  
 
528
                                   
529
529
                                   if(current_node != NULL && is_early_node_valid)
530
530
                                   {
531
531
                                       current_node = axiom_node_get_next_sibling(current_node, env);
532
 
 
533
 
 
 
532
                                       
 
533
                                       
534
534
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
535
535
                                        {
536
536
                                            current_node = axiom_node_get_next_sibling(current_node, env);
540
540
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
541
541
                                            qname = axiom_element_get_qname(current_element, env, current_node);
542
542
                                        }
543
 
 
 
543
                                       
544
544
                                   }
545
545
                                   is_early_node_valid = AXIS2_FALSE;
546
 
 
 
546
                                 
547
547
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
548
 
 
549
 
 
550
 
                           if (
 
548
                                 
 
549
 
 
550
                           if ( 
551
551
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
552
552
                           {
553
553
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
554
554
                              {
555
555
                                is_early_node_valid = AXIS2_TRUE;
556
556
                              }
557
 
 
558
 
 
 
557
                              
 
558
                                 
559
559
                                      text_value = axiom_element_get_text(current_element, env, current_node);
560
560
                                      if(text_value != NULL)
561
561
                                      {
570
570
                                                                      AXIS2_FALSE);
571
571
                                            }
572
572
                                      }
573
 
 
 
573
                                      
574
574
                                      else
575
575
                                      {
576
576
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
577
577
                                          status = AXIS2_FAILURE;
578
578
                                      }
579
 
 
 
579
                                      
580
580
                                 if(AXIS2_FAILURE ==  status)
581
581
                                 {
582
582
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
587
587
                                     return AXIS2_FAILURE;
588
588
                                 }
589
589
                              }
590
 
 
 
590
                           
591
591
                  if(element_qname)
592
592
                  {
593
593
                     axutil_qname_free(element_qname, env);
594
594
                     element_qname = NULL;
595
595
                  }
596
 
 
597
 
 
598
 
 
 
596
                 
 
597
 
 
598
                     
599
599
                     /*
600
600
                      * building source element
601
601
                      */
602
 
 
603
 
 
604
 
 
 
602
                     
 
603
                     
 
604
                     
605
605
                                    /*
606
606
                                     * because elements are ordered this works fine
607
607
                                     */
608
 
 
609
 
 
 
608
                                  
 
609
                                   
610
610
                                   if(current_node != NULL && is_early_node_valid)
611
611
                                   {
612
612
                                       current_node = axiom_node_get_next_sibling(current_node, env);
613
 
 
614
 
 
 
613
                                       
 
614
                                       
615
615
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
616
616
                                        {
617
617
                                            current_node = axiom_node_get_next_sibling(current_node, env);
621
621
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
622
622
                                            qname = axiom_element_get_qname(current_element, env, current_node);
623
623
                                        }
624
 
 
 
624
                                       
625
625
                                   }
626
626
                                   is_early_node_valid = AXIS2_FALSE;
627
 
 
 
627
                                 
628
628
                                 element_qname = axutil_qname_create(env, "source", "http://eucalyptus.ucsb.edu/", NULL);
629
 
 
630
 
 
631
 
                           if (
 
629
                                 
 
630
 
 
631
                           if ( 
632
632
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
633
633
                           {
634
634
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
635
635
                              {
636
636
                                is_early_node_valid = AXIS2_TRUE;
637
637
                              }
638
 
 
639
 
 
 
638
                              
 
639
                                 
640
640
                                      text_value = axiom_element_get_text(current_element, env, current_node);
641
641
                                      if(text_value != NULL)
642
642
                                      {
643
643
                                            status = adb_unassignAddressType_set_source(_unassignAddressType, env,
644
644
                                                               text_value);
645
645
                                      }
646
 
 
 
646
                                      
647
647
                                      else
648
648
                                      {
649
649
                                            /*
650
650
                                             * axis2_qname_t *qname = NULL;
651
651
                                             * axiom_attribute_t *the_attri = NULL;
652
 
                                             *
 
652
                                             * 
653
653
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
654
654
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
655
655
                                             */
667
667
                                                 axutil_hash_index_t *hi;
668
668
                                                 void *val;
669
669
                                                 const void *key;
670
 
 
671
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
670
                                        
 
671
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
672
672
                                                 {
673
673
                                                     axutil_hash_this(hi, &key, NULL, &val);
674
 
 
 
674
                                                     
675
675
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
676
676
                                                     {
677
677
                                                         the_attri = (axiom_attribute_t*)val;
702
702
                                                                   "");
703
703
                                            }
704
704
                                      }
705
 
 
 
705
                                      
706
706
                                 if(AXIS2_FAILURE ==  status)
707
707
                                 {
708
708
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for source ");
713
713
                                     return AXIS2_FAILURE;
714
714
                                 }
715
715
                              }
716
 
 
 
716
                           
717
717
                              else if(!dont_care_minoccurs)
718
718
                              {
719
719
                                  if(element_qname)
724
724
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element source missing");
725
725
                                  return AXIS2_FAILURE;
726
726
                              }
727
 
 
 
727
                           
728
728
                  if(element_qname)
729
729
                  {
730
730
                     axutil_qname_free(element_qname, env);
731
731
                     element_qname = NULL;
732
732
                  }
733
 
 
734
 
 
735
 
 
 
733
                 
 
734
 
 
735
                     
736
736
                     /*
737
737
                      * building dest element
738
738
                      */
739
 
 
740
 
 
741
 
 
 
739
                     
 
740
                     
 
741
                     
742
742
                                    /*
743
743
                                     * because elements are ordered this works fine
744
744
                                     */
745
 
 
746
 
 
 
745
                                  
 
746
                                   
747
747
                                   if(current_node != NULL && is_early_node_valid)
748
748
                                   {
749
749
                                       current_node = axiom_node_get_next_sibling(current_node, env);
750
 
 
751
 
 
 
750
                                       
 
751
                                       
752
752
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
753
753
                                        {
754
754
                                            current_node = axiom_node_get_next_sibling(current_node, env);
758
758
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
759
759
                                            qname = axiom_element_get_qname(current_element, env, current_node);
760
760
                                        }
761
 
 
 
761
                                       
762
762
                                   }
763
763
                                   is_early_node_valid = AXIS2_FALSE;
764
 
 
 
764
                                 
765
765
                                 element_qname = axutil_qname_create(env, "dest", "http://eucalyptus.ucsb.edu/", NULL);
766
 
 
767
 
 
768
 
                           if (
 
766
                                 
 
767
 
 
768
                           if ( 
769
769
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
770
770
                           {
771
771
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
772
772
                              {
773
773
                                is_early_node_valid = AXIS2_TRUE;
774
774
                              }
775
 
 
776
 
 
 
775
                              
 
776
                                 
777
777
                                      text_value = axiom_element_get_text(current_element, env, current_node);
778
778
                                      if(text_value != NULL)
779
779
                                      {
780
780
                                            status = adb_unassignAddressType_set_dest(_unassignAddressType, env,
781
781
                                                               text_value);
782
782
                                      }
783
 
 
 
783
                                      
784
784
                                      else
785
785
                                      {
786
786
                                            /*
787
787
                                             * axis2_qname_t *qname = NULL;
788
788
                                             * axiom_attribute_t *the_attri = NULL;
789
 
                                             *
 
789
                                             * 
790
790
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
791
791
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
792
792
                                             */
804
804
                                                 axutil_hash_index_t *hi;
805
805
                                                 void *val;
806
806
                                                 const void *key;
807
 
 
808
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
807
                                        
 
808
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
809
809
                                                 {
810
810
                                                     axutil_hash_this(hi, &key, NULL, &val);
811
 
 
 
811
                                                     
812
812
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
813
813
                                                     {
814
814
                                                         the_attri = (axiom_attribute_t*)val;
839
839
                                                                   "");
840
840
                                            }
841
841
                                      }
842
 
 
 
842
                                      
843
843
                                 if(AXIS2_FAILURE ==  status)
844
844
                                 {
845
845
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for dest ");
850
850
                                     return AXIS2_FAILURE;
851
851
                                 }
852
852
                              }
853
 
 
 
853
                           
854
854
                              else if(!dont_care_minoccurs)
855
855
                              {
856
856
                                  if(element_qname)
861
861
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element dest missing");
862
862
                                  return AXIS2_FAILURE;
863
863
                              }
864
 
 
 
864
                           
865
865
                  if(element_qname)
866
866
                  {
867
867
                     axutil_qname_free(element_qname, env);
868
868
                     element_qname = NULL;
869
869
                  }
870
 
 
 
870
                 
871
871
          return status;
872
872
       }
873
873
 
874
874
          axis2_bool_t AXIS2_CALL
875
875
          adb_unassignAddressType_is_particle()
876
876
          {
877
 
 
 
877
            
878
878
                 return AXIS2_FALSE;
879
 
 
 
879
              
880
880
          }
881
881
 
882
882
 
886
886
                    const axutil_env_t *env, axiom_element_t *parent_element,
887
887
                    axutil_hash_t *namespaces, int *next_ns_index)
888
888
          {
889
 
 
 
889
            
890
890
                  /* Here this is an empty function, Nothing to declare */
891
 
 
 
891
                 
892
892
          }
893
893
 
894
 
 
895
 
 
 
894
        
 
895
        
896
896
        axiom_node_t* AXIS2_CALL
897
897
        adb_unassignAddressType_serialize(
898
898
                adb_unassignAddressType_t* _unassignAddressType,
899
899
                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)
900
900
        {
901
 
 
902
 
 
 
901
            
 
902
            
903
903
             axis2_char_t *string_to_stream;
904
 
 
905
 
 
 
904
            
 
905
         
906
906
         axiom_node_t *current_node = NULL;
907
907
         int tag_closed = 0;
908
908
 
909
 
 
910
 
 
 
909
         
 
910
         
911
911
                axiom_namespace_t *ns1 = NULL;
912
912
 
913
913
                axis2_char_t *qname_uri = NULL;
914
914
                axis2_char_t *qname_prefix = NULL;
915
915
                axis2_char_t *p_prefix = NULL;
916
916
                axis2_bool_t ns_already_defined;
917
 
 
 
917
            
918
918
                    axis2_char_t *text_value_1;
919
919
                    axis2_char_t *text_value_1_temp;
920
 
 
 
920
                    
921
921
                    axis2_char_t *text_value_2;
922
922
                    axis2_char_t *text_value_2_temp;
923
 
 
 
923
                    
924
924
                    axis2_char_t *text_value_3;
925
925
                    axis2_char_t *text_value_3_temp;
926
 
 
 
926
                    
927
927
                    axis2_char_t text_value_4[64];
928
 
 
 
928
                    
929
929
                    axis2_char_t *text_value_5;
930
930
                    axis2_char_t *text_value_5_temp;
931
 
 
 
931
                    
932
932
                    axis2_char_t *text_value_6;
933
933
                    axis2_char_t *text_value_6_temp;
934
 
 
 
934
                    
935
935
               axis2_char_t *start_input_str = NULL;
936
936
               axis2_char_t *end_input_str = NULL;
937
937
               unsigned int start_input_str_len = 0;
938
938
               unsigned int end_input_str_len = 0;
939
 
 
940
 
 
 
939
            
 
940
            
941
941
               axiom_data_source_t *data_source = NULL;
942
942
               axutil_stream_t *stream = NULL;
943
943
 
944
 
 
 
944
            
945
945
 
946
946
            AXIS2_ENV_CHECK(env, NULL);
947
947
            AXIS2_PARAM_CHECK(env->error, _unassignAddressType, NULL);
948
 
 
949
 
 
 
948
            
 
949
            
950
950
                    current_node = parent;
951
951
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
952
952
                    if (!data_source)
954
954
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
955
955
                    if (!stream)
956
956
                        return NULL;
957
 
 
 
957
                  
958
958
            if(!parent_tag_closed)
959
959
            {
960
 
 
961
 
              string_to_stream = ">";
 
960
            
 
961
              string_to_stream = ">"; 
962
962
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
963
963
              tag_closed = 1;
964
 
 
 
964
            
965
965
            }
966
 
 
 
966
            
967
967
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
968
968
                       {
969
969
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
970
970
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
971
971
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
972
 
 
 
972
                           
973
973
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
974
974
                                            "http://eucalyptus.ucsb.edu/",
975
975
                                            p_prefix));
976
976
                       }
977
 
 
 
977
                      
978
978
 
979
979
                   if (!_unassignAddressType->is_valid_correlationId)
980
980
                   {
981
 
 
 
981
                      
982
982
                           /* no need to complain for minoccurs=0 element */
983
 
 
984
 
 
 
983
                            
 
984
                          
985
985
                   }
986
986
                   else
987
987
                   {
988
988
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
989
 
                                 (4 + axutil_strlen(p_prefix) +
990
 
                                  axutil_strlen("correlationId")));
991
 
 
 
989
                                 (4 + axutil_strlen(p_prefix) + 
 
990
                                  axutil_strlen("correlationId"))); 
 
991
                                 
992
992
                                 /* axutil_strlen("<:>") + 1 = 4 */
993
993
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
994
994
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
995
995
                                  /* axutil_strlen("</:>") + 1 = 5 */
996
 
 
997
 
 
998
 
 
999
 
 
1000
 
 
1001
 
 
 
996
                                  
 
997
                     
 
998
 
 
999
                   
 
1000
                   
 
1001
                     
1002
1002
                     /*
1003
1003
                      * parsing correlationId element
1004
1004
                      */
1005
1005
 
1006
 
 
1007
 
 
 
1006
                    
 
1007
                    
1008
1008
                            sprintf(start_input_str, "<%s%scorrelationId>",
1009
1009
                                 p_prefix?p_prefix:"",
1010
1010
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1011
 
 
 
1011
                            
1012
1012
                        start_input_str_len = axutil_strlen(start_input_str);
1013
1013
                        sprintf(end_input_str, "</%s%scorrelationId>",
1014
1014
                                 p_prefix?p_prefix:"",
1015
1015
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1016
1016
                        end_input_str_len = axutil_strlen(end_input_str);
1017
 
 
 
1017
                    
1018
1018
                           text_value_1 = _unassignAddressType->property_correlationId;
1019
 
 
 
1019
                           
1020
1020
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1021
 
 
1022
 
 
 
1021
                           
 
1022
                            
1023
1023
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
1024
1024
                           if (text_value_1_temp)
1025
1025
                           {
1030
1030
                           {
1031
1031
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
1032
1032
                           }
1033
 
 
 
1033
                           
1034
1034
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1035
 
 
1036
 
 
 
1035
                           
 
1036
                     
1037
1037
                     AXIS2_FREE(env->allocator,start_input_str);
1038
1038
                     AXIS2_FREE(env->allocator,end_input_str);
1039
 
                 }
1040
 
 
1041
 
 
 
1039
                 } 
 
1040
 
 
1041
                 
1042
1042
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1043
1043
                       {
1044
1044
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1045
1045
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1046
1046
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1047
 
 
 
1047
                           
1048
1048
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1049
1049
                                            "http://eucalyptus.ucsb.edu/",
1050
1050
                                            p_prefix));
1051
1051
                       }
1052
 
 
 
1052
                      
1053
1053
 
1054
1054
                   if (!_unassignAddressType->is_valid_userId)
1055
1055
                   {
1056
 
 
 
1056
                      
1057
1057
                           /* no need to complain for minoccurs=0 element */
1058
 
 
1059
 
 
 
1058
                            
 
1059
                          
1060
1060
                   }
1061
1061
                   else
1062
1062
                   {
1063
1063
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1064
 
                                 (4 + axutil_strlen(p_prefix) +
1065
 
                                  axutil_strlen("userId")));
1066
 
 
 
1064
                                 (4 + axutil_strlen(p_prefix) + 
 
1065
                                  axutil_strlen("userId"))); 
 
1066
                                 
1067
1067
                                 /* axutil_strlen("<:>") + 1 = 4 */
1068
1068
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1069
1069
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
1070
1070
                                  /* axutil_strlen("</:>") + 1 = 5 */
1071
 
 
1072
 
 
1073
 
 
1074
 
 
1075
 
 
1076
 
 
 
1071
                                  
 
1072
                     
 
1073
 
 
1074
                   
 
1075
                   
 
1076
                     
1077
1077
                     /*
1078
1078
                      * parsing userId element
1079
1079
                      */
1080
1080
 
1081
 
 
1082
 
 
 
1081
                    
 
1082
                    
1083
1083
                            sprintf(start_input_str, "<%s%suserId>",
1084
1084
                                 p_prefix?p_prefix:"",
1085
1085
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1086
 
 
 
1086
                            
1087
1087
                        start_input_str_len = axutil_strlen(start_input_str);
1088
1088
                        sprintf(end_input_str, "</%s%suserId>",
1089
1089
                                 p_prefix?p_prefix:"",
1090
1090
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1091
1091
                        end_input_str_len = axutil_strlen(end_input_str);
1092
 
 
 
1092
                    
1093
1093
                           text_value_2 = _unassignAddressType->property_userId;
1094
 
 
 
1094
                           
1095
1095
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1096
 
 
1097
 
 
 
1096
                           
 
1097
                            
1098
1098
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
1099
1099
                           if (text_value_2_temp)
1100
1100
                           {
1105
1105
                           {
1106
1106
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
1107
1107
                           }
1108
 
 
 
1108
                           
1109
1109
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1110
 
 
1111
 
 
 
1110
                           
 
1111
                     
1112
1112
                     AXIS2_FREE(env->allocator,start_input_str);
1113
1113
                     AXIS2_FREE(env->allocator,end_input_str);
1114
 
                 }
1115
 
 
1116
 
 
 
1114
                 } 
 
1115
 
 
1116
                 
1117
1117
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1118
1118
                       {
1119
1119
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1120
1120
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1121
1121
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1122
 
 
 
1122
                           
1123
1123
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1124
1124
                                            "http://eucalyptus.ucsb.edu/",
1125
1125
                                            p_prefix));
1126
1126
                       }
1127
 
 
 
1127
                      
1128
1128
 
1129
1129
                   if (!_unassignAddressType->is_valid_statusMessage)
1130
1130
                   {
1131
 
 
 
1131
                      
1132
1132
                           /* no need to complain for minoccurs=0 element */
1133
 
 
1134
 
 
 
1133
                            
 
1134
                          
1135
1135
                   }
1136
1136
                   else
1137
1137
                   {
1138
1138
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1139
 
                                 (4 + axutil_strlen(p_prefix) +
1140
 
                                  axutil_strlen("statusMessage")));
1141
 
 
 
1139
                                 (4 + axutil_strlen(p_prefix) + 
 
1140
                                  axutil_strlen("statusMessage"))); 
 
1141
                                 
1142
1142
                                 /* axutil_strlen("<:>") + 1 = 4 */
1143
1143
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1144
1144
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
1145
1145
                                  /* axutil_strlen("</:>") + 1 = 5 */
1146
 
 
1147
 
 
1148
 
 
1149
 
 
1150
 
 
1151
 
 
 
1146
                                  
 
1147
                     
 
1148
 
 
1149
                   
 
1150
                   
 
1151
                     
1152
1152
                     /*
1153
1153
                      * parsing statusMessage element
1154
1154
                      */
1155
1155
 
1156
 
 
1157
 
 
 
1156
                    
 
1157
                    
1158
1158
                            sprintf(start_input_str, "<%s%sstatusMessage>",
1159
1159
                                 p_prefix?p_prefix:"",
1160
1160
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1161
 
 
 
1161
                            
1162
1162
                        start_input_str_len = axutil_strlen(start_input_str);
1163
1163
                        sprintf(end_input_str, "</%s%sstatusMessage>",
1164
1164
                                 p_prefix?p_prefix:"",
1165
1165
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1166
1166
                        end_input_str_len = axutil_strlen(end_input_str);
1167
 
 
 
1167
                    
1168
1168
                           text_value_3 = _unassignAddressType->property_statusMessage;
1169
 
 
 
1169
                           
1170
1170
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1171
 
 
1172
 
 
 
1171
                           
 
1172
                            
1173
1173
                           text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
1174
1174
                           if (text_value_3_temp)
1175
1175
                           {
1180
1180
                           {
1181
1181
                               axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
1182
1182
                           }
1183
 
 
 
1183
                           
1184
1184
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1185
 
 
1186
 
 
 
1185
                           
 
1186
                     
1187
1187
                     AXIS2_FREE(env->allocator,start_input_str);
1188
1188
                     AXIS2_FREE(env->allocator,end_input_str);
1189
 
                 }
1190
 
 
1191
 
 
 
1189
                 } 
 
1190
 
 
1191
                 
1192
1192
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1193
1193
                       {
1194
1194
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1195
1195
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1196
1196
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1197
 
 
 
1197
                           
1198
1198
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1199
1199
                                            "http://eucalyptus.ucsb.edu/",
1200
1200
                                            p_prefix));
1201
1201
                       }
1202
 
 
 
1202
                      
1203
1203
 
1204
1204
                   if (!_unassignAddressType->is_valid_return)
1205
1205
                   {
1206
 
 
 
1206
                      
1207
1207
                           /* no need to complain for minoccurs=0 element */
1208
 
 
1209
 
 
 
1208
                            
 
1209
                          
1210
1210
                   }
1211
1211
                   else
1212
1212
                   {
1213
1213
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1214
 
                                 (4 + axutil_strlen(p_prefix) +
1215
 
                                  axutil_strlen("return")));
1216
 
 
 
1214
                                 (4 + axutil_strlen(p_prefix) + 
 
1215
                                  axutil_strlen("return"))); 
 
1216
                                 
1217
1217
                                 /* axutil_strlen("<:>") + 1 = 4 */
1218
1218
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1219
1219
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
1220
1220
                                  /* axutil_strlen("</:>") + 1 = 5 */
1221
 
 
1222
 
 
1223
 
 
1224
 
 
1225
 
 
1226
 
 
 
1221
                                  
 
1222
                     
 
1223
 
 
1224
                   
 
1225
                   
 
1226
                     
1227
1227
                     /*
1228
1228
                      * parsing return element
1229
1229
                      */
1230
1230
 
1231
 
 
1232
 
 
 
1231
                    
 
1232
                    
1233
1233
                            sprintf(start_input_str, "<%s%sreturn>",
1234
1234
                                 p_prefix?p_prefix:"",
1235
1235
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1236
 
 
 
1236
                            
1237
1237
                        start_input_str_len = axutil_strlen(start_input_str);
1238
1238
                        sprintf(end_input_str, "</%s%sreturn>",
1239
1239
                                 p_prefix?p_prefix:"",
1240
1240
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1241
1241
                        end_input_str_len = axutil_strlen(end_input_str);
1242
 
 
 
1242
                    
1243
1243
                           strcpy(text_value_4, (_unassignAddressType->property_return)?"true":"false");
1244
 
 
 
1244
                           
1245
1245
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1246
 
 
 
1246
                           
1247
1247
                           axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
1248
 
 
 
1248
                           
1249
1249
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1250
 
 
1251
 
 
 
1250
                           
 
1251
                     
1252
1252
                     AXIS2_FREE(env->allocator,start_input_str);
1253
1253
                     AXIS2_FREE(env->allocator,end_input_str);
1254
 
                 }
1255
 
 
1256
 
 
 
1254
                 } 
 
1255
 
 
1256
                 
1257
1257
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1258
1258
                       {
1259
1259
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1260
1260
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1261
1261
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1262
 
 
 
1262
                           
1263
1263
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1264
1264
                                            "http://eucalyptus.ucsb.edu/",
1265
1265
                                            p_prefix));
1266
1266
                       }
1267
 
 
 
1267
                      
1268
1268
 
1269
1269
                   if (!_unassignAddressType->is_valid_source)
1270
1270
                   {
1271
 
 
1272
 
 
 
1271
                      
 
1272
                            
1273
1273
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property source");
1274
1274
                            return NULL;
1275
 
 
 
1275
                          
1276
1276
                   }
1277
1277
                   else
1278
1278
                   {
1279
1279
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1280
 
                                 (4 + axutil_strlen(p_prefix) +
1281
 
                                  axutil_strlen("source")));
1282
 
 
 
1280
                                 (4 + axutil_strlen(p_prefix) + 
 
1281
                                  axutil_strlen("source"))); 
 
1282
                                 
1283
1283
                                 /* axutil_strlen("<:>") + 1 = 4 */
1284
1284
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1285
1285
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("source")));
1286
1286
                                  /* axutil_strlen("</:>") + 1 = 5 */
1287
 
 
1288
 
 
1289
 
 
1290
 
 
1291
 
 
1292
 
 
 
1287
                                  
 
1288
                     
 
1289
 
 
1290
                   
 
1291
                   
 
1292
                     
1293
1293
                     /*
1294
1294
                      * parsing source element
1295
1295
                      */
1296
1296
 
1297
 
 
1298
 
 
 
1297
                    
 
1298
                    
1299
1299
                            sprintf(start_input_str, "<%s%ssource>",
1300
1300
                                 p_prefix?p_prefix:"",
1301
1301
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1302
 
 
 
1302
                            
1303
1303
                        start_input_str_len = axutil_strlen(start_input_str);
1304
1304
                        sprintf(end_input_str, "</%s%ssource>",
1305
1305
                                 p_prefix?p_prefix:"",
1306
1306
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1307
1307
                        end_input_str_len = axutil_strlen(end_input_str);
1308
 
 
 
1308
                    
1309
1309
                           text_value_5 = _unassignAddressType->property_source;
1310
 
 
 
1310
                           
1311
1311
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1312
 
 
1313
 
 
 
1312
                           
 
1313
                            
1314
1314
                           text_value_5_temp = axutil_xml_quote_string(env, text_value_5, AXIS2_TRUE);
1315
1315
                           if (text_value_5_temp)
1316
1316
                           {
1321
1321
                           {
1322
1322
                               axutil_stream_write(stream, env, text_value_5, axutil_strlen(text_value_5));
1323
1323
                           }
1324
 
 
 
1324
                           
1325
1325
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1326
 
 
1327
 
 
 
1326
                           
 
1327
                     
1328
1328
                     AXIS2_FREE(env->allocator,start_input_str);
1329
1329
                     AXIS2_FREE(env->allocator,end_input_str);
1330
 
                 }
1331
 
 
1332
 
 
 
1330
                 } 
 
1331
 
 
1332
                 
1333
1333
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
1334
1334
                       {
1335
1335
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
1336
1336
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
1337
1337
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
1338
 
 
 
1338
                           
1339
1339
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
1340
1340
                                            "http://eucalyptus.ucsb.edu/",
1341
1341
                                            p_prefix));
1342
1342
                       }
1343
 
 
 
1343
                      
1344
1344
 
1345
1345
                   if (!_unassignAddressType->is_valid_dest)
1346
1346
                   {
1347
 
 
1348
 
 
 
1347
                      
 
1348
                            
1349
1349
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Nil value found in non-nillable property dest");
1350
1350
                            return NULL;
1351
 
 
 
1351
                          
1352
1352
                   }
1353
1353
                   else
1354
1354
                   {
1355
1355
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1356
 
                                 (4 + axutil_strlen(p_prefix) +
1357
 
                                  axutil_strlen("dest")));
1358
 
 
 
1356
                                 (4 + axutil_strlen(p_prefix) + 
 
1357
                                  axutil_strlen("dest"))); 
 
1358
                                 
1359
1359
                                 /* axutil_strlen("<:>") + 1 = 4 */
1360
1360
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
1361
1361
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("dest")));
1362
1362
                                  /* axutil_strlen("</:>") + 1 = 5 */
1363
 
 
1364
 
 
1365
 
 
1366
 
 
1367
 
 
1368
 
 
 
1363
                                  
 
1364
                     
 
1365
 
 
1366
                   
 
1367
                   
 
1368
                     
1369
1369
                     /*
1370
1370
                      * parsing dest element
1371
1371
                      */
1372
1372
 
1373
 
 
1374
 
 
 
1373
                    
 
1374
                    
1375
1375
                            sprintf(start_input_str, "<%s%sdest>",
1376
1376
                                 p_prefix?p_prefix:"",
1377
1377
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1378
 
 
 
1378
                            
1379
1379
                        start_input_str_len = axutil_strlen(start_input_str);
1380
1380
                        sprintf(end_input_str, "</%s%sdest>",
1381
1381
                                 p_prefix?p_prefix:"",
1382
1382
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
1383
1383
                        end_input_str_len = axutil_strlen(end_input_str);
1384
 
 
 
1384
                    
1385
1385
                           text_value_6 = _unassignAddressType->property_dest;
1386
 
 
 
1386
                           
1387
1387
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
1388
 
 
1389
 
 
 
1388
                           
 
1389
                            
1390
1390
                           text_value_6_temp = axutil_xml_quote_string(env, text_value_6, AXIS2_TRUE);
1391
1391
                           if (text_value_6_temp)
1392
1392
                           {
1397
1397
                           {
1398
1398
                               axutil_stream_write(stream, env, text_value_6, axutil_strlen(text_value_6));
1399
1399
                           }
1400
 
 
 
1400
                           
1401
1401
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
1402
 
 
1403
 
 
 
1402
                           
 
1403
                     
1404
1404
                     AXIS2_FREE(env->allocator,start_input_str);
1405
1405
                     AXIS2_FREE(env->allocator,end_input_str);
1406
 
                 }
1407
 
 
1408
 
 
 
1406
                 } 
 
1407
 
 
1408
                 
1409
1409
 
1410
1410
            return parent;
1411
1411
        }
1412
1412
 
1413
1413
 
1414
 
 
 
1414
        
1415
1415
 
1416
1416
            /**
1417
1417
             * getter for correlationId.
1421
1421
                    adb_unassignAddressType_t* _unassignAddressType,
1422
1422
                    const axutil_env_t *env)
1423
1423
             {
1424
 
 
 
1424
                
1425
1425
                    AXIS2_ENV_CHECK(env, NULL);
1426
1426
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressType, NULL);
1427
 
 
 
1427
                  
1428
1428
 
1429
1429
                return _unassignAddressType->property_correlationId;
1430
1430
             }
1438
1438
                    const axutil_env_t *env,
1439
1439
                    const axis2_char_t*  arg_correlationId)
1440
1440
             {
1441
 
 
 
1441
                
1442
1442
 
1443
1443
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1444
1444
                AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1445
 
 
 
1445
                
1446
1446
                if(_unassignAddressType->is_valid_correlationId &&
1447
1447
                        arg_correlationId == _unassignAddressType->property_correlationId)
1448
1448
                {
1449
 
 
1450
 
                    return AXIS2_SUCCESS;
 
1449
                    
 
1450
                    return AXIS2_SUCCESS; 
1451
1451
                }
1452
1452
 
1453
1453
                adb_unassignAddressType_reset_correlationId(_unassignAddressType, env);
1454
1454
 
1455
 
 
 
1455
                
1456
1456
                if(NULL == arg_correlationId)
1457
1457
                {
1458
1458
                    /* We are already done */
1465
1465
                            return AXIS2_FAILURE;
1466
1466
                        }
1467
1467
                        _unassignAddressType->is_valid_correlationId = AXIS2_TRUE;
1468
 
 
 
1468
                    
1469
1469
                return AXIS2_SUCCESS;
1470
1470
             }
1471
1471
 
1472
 
 
 
1472
             
1473
1473
 
1474
1474
           /**
1475
1475
            * resetter for correlationId
1485
1485
 
1486
1486
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1487
1487
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1488
 
 
1489
 
 
1490
 
 
1491
 
 
1492
 
 
 
1488
               
 
1489
 
 
1490
               
 
1491
            
 
1492
                
1493
1493
                if(_unassignAddressType->property_correlationId != NULL)
1494
1494
                {
1495
 
 
1496
 
 
 
1495
                   
 
1496
                   
1497
1497
                        AXIS2_FREE(env-> allocator, _unassignAddressType->property_correlationId);
1498
1498
                     _unassignAddressType->property_correlationId = NULL;
1499
1499
                }
1500
 
 
1501
 
 
1502
 
 
1503
 
                _unassignAddressType->is_valid_correlationId = AXIS2_FALSE;
 
1500
            
 
1501
                
 
1502
                
 
1503
                _unassignAddressType->is_valid_correlationId = AXIS2_FALSE; 
1504
1504
               return AXIS2_SUCCESS;
1505
1505
           }
1506
1506
 
1514
1514
           {
1515
1515
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1516
1516
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_TRUE);
1517
 
 
 
1517
               
1518
1518
               return !_unassignAddressType->is_valid_correlationId;
1519
1519
           }
1520
1520
 
1529
1529
               return adb_unassignAddressType_reset_correlationId(_unassignAddressType, env);
1530
1530
           }
1531
1531
 
1532
 
 
 
1532
           
1533
1533
 
1534
1534
            /**
1535
1535
             * getter for userId.
1539
1539
                    adb_unassignAddressType_t* _unassignAddressType,
1540
1540
                    const axutil_env_t *env)
1541
1541
             {
1542
 
 
 
1542
                
1543
1543
                    AXIS2_ENV_CHECK(env, NULL);
1544
1544
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressType, NULL);
1545
 
 
 
1545
                  
1546
1546
 
1547
1547
                return _unassignAddressType->property_userId;
1548
1548
             }
1556
1556
                    const axutil_env_t *env,
1557
1557
                    const axis2_char_t*  arg_userId)
1558
1558
             {
1559
 
 
 
1559
                
1560
1560
 
1561
1561
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1562
1562
                AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1563
 
 
 
1563
                
1564
1564
                if(_unassignAddressType->is_valid_userId &&
1565
1565
                        arg_userId == _unassignAddressType->property_userId)
1566
1566
                {
1567
 
 
1568
 
                    return AXIS2_SUCCESS;
 
1567
                    
 
1568
                    return AXIS2_SUCCESS; 
1569
1569
                }
1570
1570
 
1571
1571
                adb_unassignAddressType_reset_userId(_unassignAddressType, env);
1572
1572
 
1573
 
 
 
1573
                
1574
1574
                if(NULL == arg_userId)
1575
1575
                {
1576
1576
                    /* We are already done */
1583
1583
                            return AXIS2_FAILURE;
1584
1584
                        }
1585
1585
                        _unassignAddressType->is_valid_userId = AXIS2_TRUE;
1586
 
 
 
1586
                    
1587
1587
                return AXIS2_SUCCESS;
1588
1588
             }
1589
1589
 
1590
 
 
 
1590
             
1591
1591
 
1592
1592
           /**
1593
1593
            * resetter for userId
1603
1603
 
1604
1604
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1605
1605
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1606
 
 
1607
 
 
1608
 
 
1609
 
 
1610
 
 
 
1606
               
 
1607
 
 
1608
               
 
1609
            
 
1610
                
1611
1611
                if(_unassignAddressType->property_userId != NULL)
1612
1612
                {
1613
 
 
1614
 
 
 
1613
                   
 
1614
                   
1615
1615
                        AXIS2_FREE(env-> allocator, _unassignAddressType->property_userId);
1616
1616
                     _unassignAddressType->property_userId = NULL;
1617
1617
                }
1618
 
 
1619
 
 
1620
 
 
1621
 
                _unassignAddressType->is_valid_userId = AXIS2_FALSE;
 
1618
            
 
1619
                
 
1620
                
 
1621
                _unassignAddressType->is_valid_userId = AXIS2_FALSE; 
1622
1622
               return AXIS2_SUCCESS;
1623
1623
           }
1624
1624
 
1632
1632
           {
1633
1633
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1634
1634
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_TRUE);
1635
 
 
 
1635
               
1636
1636
               return !_unassignAddressType->is_valid_userId;
1637
1637
           }
1638
1638
 
1647
1647
               return adb_unassignAddressType_reset_userId(_unassignAddressType, env);
1648
1648
           }
1649
1649
 
1650
 
 
 
1650
           
1651
1651
 
1652
1652
            /**
1653
1653
             * getter for statusMessage.
1657
1657
                    adb_unassignAddressType_t* _unassignAddressType,
1658
1658
                    const axutil_env_t *env)
1659
1659
             {
1660
 
 
 
1660
                
1661
1661
                    AXIS2_ENV_CHECK(env, NULL);
1662
1662
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressType, NULL);
1663
 
 
 
1663
                  
1664
1664
 
1665
1665
                return _unassignAddressType->property_statusMessage;
1666
1666
             }
1674
1674
                    const axutil_env_t *env,
1675
1675
                    const axis2_char_t*  arg_statusMessage)
1676
1676
             {
1677
 
 
 
1677
                
1678
1678
 
1679
1679
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1680
1680
                AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1681
 
 
 
1681
                
1682
1682
                if(_unassignAddressType->is_valid_statusMessage &&
1683
1683
                        arg_statusMessage == _unassignAddressType->property_statusMessage)
1684
1684
                {
1685
 
 
1686
 
                    return AXIS2_SUCCESS;
 
1685
                    
 
1686
                    return AXIS2_SUCCESS; 
1687
1687
                }
1688
1688
 
1689
1689
                adb_unassignAddressType_reset_statusMessage(_unassignAddressType, env);
1690
1690
 
1691
 
 
 
1691
                
1692
1692
                if(NULL == arg_statusMessage)
1693
1693
                {
1694
1694
                    /* We are already done */
1701
1701
                            return AXIS2_FAILURE;
1702
1702
                        }
1703
1703
                        _unassignAddressType->is_valid_statusMessage = AXIS2_TRUE;
1704
 
 
 
1704
                    
1705
1705
                return AXIS2_SUCCESS;
1706
1706
             }
1707
1707
 
1708
 
 
 
1708
             
1709
1709
 
1710
1710
           /**
1711
1711
            * resetter for statusMessage
1721
1721
 
1722
1722
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1723
1723
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1724
 
 
1725
 
 
1726
 
 
1727
 
 
1728
 
 
 
1724
               
 
1725
 
 
1726
               
 
1727
            
 
1728
                
1729
1729
                if(_unassignAddressType->property_statusMessage != NULL)
1730
1730
                {
1731
 
 
1732
 
 
 
1731
                   
 
1732
                   
1733
1733
                        AXIS2_FREE(env-> allocator, _unassignAddressType->property_statusMessage);
1734
1734
                     _unassignAddressType->property_statusMessage = NULL;
1735
1735
                }
1736
 
 
1737
 
 
1738
 
 
1739
 
                _unassignAddressType->is_valid_statusMessage = AXIS2_FALSE;
 
1736
            
 
1737
                
 
1738
                
 
1739
                _unassignAddressType->is_valid_statusMessage = AXIS2_FALSE; 
1740
1740
               return AXIS2_SUCCESS;
1741
1741
           }
1742
1742
 
1750
1750
           {
1751
1751
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1752
1752
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_TRUE);
1753
 
 
 
1753
               
1754
1754
               return !_unassignAddressType->is_valid_statusMessage;
1755
1755
           }
1756
1756
 
1765
1765
               return adb_unassignAddressType_reset_statusMessage(_unassignAddressType, env);
1766
1766
           }
1767
1767
 
1768
 
 
 
1768
           
1769
1769
 
1770
1770
            /**
1771
1771
             * getter for return.
1775
1775
                    adb_unassignAddressType_t* _unassignAddressType,
1776
1776
                    const axutil_env_t *env)
1777
1777
             {
1778
 
 
 
1778
                
1779
1779
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1780
1780
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressType, (axis2_bool_t)0);
1781
 
 
 
1781
                  
1782
1782
 
1783
1783
                return _unassignAddressType->property_return;
1784
1784
             }
1792
1792
                    const axutil_env_t *env,
1793
1793
                    axis2_bool_t  arg_return)
1794
1794
             {
1795
 
 
 
1795
                
1796
1796
 
1797
1797
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1798
1798
                AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1799
 
 
 
1799
                
1800
1800
                if(_unassignAddressType->is_valid_return &&
1801
1801
                        arg_return == _unassignAddressType->property_return)
1802
1802
                {
1803
 
 
1804
 
                    return AXIS2_SUCCESS;
 
1803
                    
 
1804
                    return AXIS2_SUCCESS; 
1805
1805
                }
1806
1806
 
1807
1807
                adb_unassignAddressType_reset_return(_unassignAddressType, env);
1808
1808
 
1809
1809
                _unassignAddressType->property_return = arg_return;
1810
1810
                        _unassignAddressType->is_valid_return = AXIS2_TRUE;
1811
 
 
 
1811
                    
1812
1812
                return AXIS2_SUCCESS;
1813
1813
             }
1814
1814
 
1815
 
 
 
1815
             
1816
1816
 
1817
1817
           /**
1818
1818
            * resetter for return
1828
1828
 
1829
1829
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1830
1830
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1831
 
 
1832
 
 
1833
 
               _unassignAddressType->is_valid_return = AXIS2_FALSE;
 
1831
               
 
1832
 
 
1833
               _unassignAddressType->is_valid_return = AXIS2_FALSE; 
1834
1834
               return AXIS2_SUCCESS;
1835
1835
           }
1836
1836
 
1844
1844
           {
1845
1845
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1846
1846
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_TRUE);
1847
 
 
 
1847
               
1848
1848
               return !_unassignAddressType->is_valid_return;
1849
1849
           }
1850
1850
 
1859
1859
               return adb_unassignAddressType_reset_return(_unassignAddressType, env);
1860
1860
           }
1861
1861
 
1862
 
 
 
1862
           
1863
1863
 
1864
1864
            /**
1865
1865
             * getter for source.
1869
1869
                    adb_unassignAddressType_t* _unassignAddressType,
1870
1870
                    const axutil_env_t *env)
1871
1871
             {
1872
 
 
 
1872
                
1873
1873
                    AXIS2_ENV_CHECK(env, NULL);
1874
1874
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressType, NULL);
1875
 
 
 
1875
                  
1876
1876
 
1877
1877
                return _unassignAddressType->property_source;
1878
1878
             }
1886
1886
                    const axutil_env_t *env,
1887
1887
                    const axis2_char_t*  arg_source)
1888
1888
             {
1889
 
 
 
1889
                
1890
1890
 
1891
1891
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1892
1892
                AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1893
 
 
 
1893
                
1894
1894
                if(_unassignAddressType->is_valid_source &&
1895
1895
                        arg_source == _unassignAddressType->property_source)
1896
1896
                {
1897
 
 
1898
 
                    return AXIS2_SUCCESS;
 
1897
                    
 
1898
                    return AXIS2_SUCCESS; 
1899
1899
                }
1900
1900
 
1901
 
 
 
1901
                
1902
1902
                  if(NULL == arg_source)
1903
1903
                  {
1904
1904
                      AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "source is being set to NULL, but it is not a nullable element");
1906
1906
                  }
1907
1907
                adb_unassignAddressType_reset_source(_unassignAddressType, env);
1908
1908
 
1909
 
 
 
1909
                
1910
1910
                if(NULL == arg_source)
1911
1911
                {
1912
1912
                    /* We are already done */
1919
1919
                            return AXIS2_FAILURE;
1920
1920
                        }
1921
1921
                        _unassignAddressType->is_valid_source = AXIS2_TRUE;
1922
 
 
 
1922
                    
1923
1923
                return AXIS2_SUCCESS;
1924
1924
             }
1925
1925
 
1926
 
 
 
1926
             
1927
1927
 
1928
1928
           /**
1929
1929
            * resetter for source
1939
1939
 
1940
1940
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1941
1941
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
1942
 
 
1943
 
 
1944
 
 
1945
 
 
1946
 
 
 
1942
               
 
1943
 
 
1944
               
 
1945
            
 
1946
                
1947
1947
                if(_unassignAddressType->property_source != NULL)
1948
1948
                {
1949
 
 
1950
 
 
 
1949
                   
 
1950
                   
1951
1951
                        AXIS2_FREE(env-> allocator, _unassignAddressType->property_source);
1952
1952
                     _unassignAddressType->property_source = NULL;
1953
1953
                }
1954
 
 
1955
 
 
1956
 
 
1957
 
                _unassignAddressType->is_valid_source = AXIS2_FALSE;
 
1954
            
 
1955
                
 
1956
                
 
1957
                _unassignAddressType->is_valid_source = AXIS2_FALSE; 
1958
1958
               return AXIS2_SUCCESS;
1959
1959
           }
1960
1960
 
1968
1968
           {
1969
1969
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1970
1970
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_TRUE);
1971
 
 
 
1971
               
1972
1972
               return !_unassignAddressType->is_valid_source;
1973
1973
           }
1974
1974
 
1983
1983
               return adb_unassignAddressType_reset_source(_unassignAddressType, env);
1984
1984
           }
1985
1985
 
1986
 
 
 
1986
           
1987
1987
 
1988
1988
            /**
1989
1989
             * getter for dest.
1993
1993
                    adb_unassignAddressType_t* _unassignAddressType,
1994
1994
                    const axutil_env_t *env)
1995
1995
             {
1996
 
 
 
1996
                
1997
1997
                    AXIS2_ENV_CHECK(env, NULL);
1998
1998
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressType, NULL);
1999
 
 
 
1999
                  
2000
2000
 
2001
2001
                return _unassignAddressType->property_dest;
2002
2002
             }
2010
2010
                    const axutil_env_t *env,
2011
2011
                    const axis2_char_t*  arg_dest)
2012
2012
             {
2013
 
 
 
2013
                
2014
2014
 
2015
2015
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2016
2016
                AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
2017
 
 
 
2017
                
2018
2018
                if(_unassignAddressType->is_valid_dest &&
2019
2019
                        arg_dest == _unassignAddressType->property_dest)
2020
2020
                {
2021
 
 
2022
 
                    return AXIS2_SUCCESS;
 
2021
                    
 
2022
                    return AXIS2_SUCCESS; 
2023
2023
                }
2024
2024
 
2025
 
 
 
2025
                
2026
2026
                  if(NULL == arg_dest)
2027
2027
                  {
2028
2028
                      AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "dest is being set to NULL, but it is not a nullable element");
2030
2030
                  }
2031
2031
                adb_unassignAddressType_reset_dest(_unassignAddressType, env);
2032
2032
 
2033
 
 
 
2033
                
2034
2034
                if(NULL == arg_dest)
2035
2035
                {
2036
2036
                    /* We are already done */
2043
2043
                            return AXIS2_FAILURE;
2044
2044
                        }
2045
2045
                        _unassignAddressType->is_valid_dest = AXIS2_TRUE;
2046
 
 
 
2046
                    
2047
2047
                return AXIS2_SUCCESS;
2048
2048
             }
2049
2049
 
2050
 
 
 
2050
             
2051
2051
 
2052
2052
           /**
2053
2053
            * resetter for dest
2063
2063
 
2064
2064
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
2065
2065
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_FAILURE);
2066
 
 
2067
 
 
2068
 
 
2069
 
 
2070
 
 
 
2066
               
 
2067
 
 
2068
               
 
2069
            
 
2070
                
2071
2071
                if(_unassignAddressType->property_dest != NULL)
2072
2072
                {
2073
 
 
2074
 
 
 
2073
                   
 
2074
                   
2075
2075
                        AXIS2_FREE(env-> allocator, _unassignAddressType->property_dest);
2076
2076
                     _unassignAddressType->property_dest = NULL;
2077
2077
                }
2078
 
 
2079
 
 
2080
 
 
2081
 
                _unassignAddressType->is_valid_dest = AXIS2_FALSE;
 
2078
            
 
2079
                
 
2080
                
 
2081
                _unassignAddressType->is_valid_dest = AXIS2_FALSE; 
2082
2082
               return AXIS2_SUCCESS;
2083
2083
           }
2084
2084
 
2092
2092
           {
2093
2093
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
2094
2094
               AXIS2_PARAM_CHECK(env->error, _unassignAddressType, AXIS2_TRUE);
2095
 
 
 
2095
               
2096
2096
               return !_unassignAddressType->is_valid_dest;
2097
2097
           }
2098
2098
 
2107
2107
               return adb_unassignAddressType_reset_dest(_unassignAddressType, env);
2108
2108
           }
2109
2109
 
2110
 
 
 
2110
           
2111
2111