← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cluster/generated/adb_unassignAddressResponseType.c

  • Committer: Dustin Kirkland
  • Date: 2010-07-22 08:41:57 UTC
  • mfrom: (1050.1.19 ubuntu)
  • Revision ID: kirkland@x200-20100722084157-zh2p8dkawznvxxpn
Approving Dave Walker's merge of new upstream Eucalyptus 2.0 release.

Dustin Kirkland <kirkland@canonical.com>

* New major upstream version merge, 2.0 (r1211).
  - 01-wsdl-stubs.patch, debian/wsdl.md5sums: wsdl stubs updated.
  - 11-state-cleanup-memleakfix.patch: Removed, fixed upstream.
  - 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_unassignAddressResponseType.c
 
1
 
 
2
 
 
3
        /**
 
4
         * adb_unassignAddressResponseType.c
 
5
         *
 
6
         * This file was auto-generated from WSDL
 
7
         * by the Apache Axis2/C version: SNAPSHOT  Built on : Mar 10, 2008 (08:35:52 GMT+00:00)
 
8
         */
 
9
 
 
10
        #include "adb_unassignAddressResponseType.h"
 
11
        
 
12
                /*
 
13
                 * This type was generated from the piece of schema that had
 
14
                 * name = unassignAddressResponseType
 
15
                 * Namespace URI = http://eucalyptus.ucsb.edu/
 
16
                 * Namespace Prefix = ns1
 
17
                 */
 
18
           
 
19
 
 
20
 
 
21
        struct adb_unassignAddressResponseType
 
22
        {
 
23
            axis2_char_t* property_correlationId;
 
24
 
 
25
                
 
26
                axis2_bool_t is_valid_correlationId;
 
27
 
 
28
 
 
29
            axis2_char_t* property_userId;
 
30
 
 
31
                
 
32
                axis2_bool_t is_valid_userId;
 
33
 
 
34
 
 
35
            axis2_char_t* property_statusMessage;
 
36
 
 
37
                
 
38
                axis2_bool_t is_valid_statusMessage;
 
39
 
 
40
 
 
41
            axis2_bool_t property_return;
 
42
 
 
43
                
 
44
                axis2_bool_t is_valid_return;
 
45
 
 
46
 
 
47
            
 
48
        };
 
49
 
 
50
 
 
51
       /************************* Private Function prototypes ********************************/
 
52
        
 
53
 
 
54
                axis2_status_t AXIS2_CALL
 
55
                adb_unassignAddressResponseType_set_correlationId_nil(
 
56
                        adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
57
                        const axutil_env_t *env);
 
58
            
 
59
 
 
60
                axis2_status_t AXIS2_CALL
 
61
                adb_unassignAddressResponseType_set_userId_nil(
 
62
                        adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
63
                        const axutil_env_t *env);
 
64
            
 
65
 
 
66
                axis2_status_t AXIS2_CALL
 
67
                adb_unassignAddressResponseType_set_return_nil(
 
68
                        adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
69
                        const axutil_env_t *env);
 
70
            
 
71
 
 
72
 
 
73
       /************************* Function Implmentations ********************************/
 
74
        adb_unassignAddressResponseType_t* AXIS2_CALL
 
75
        adb_unassignAddressResponseType_create(
 
76
            const axutil_env_t *env)
 
77
        {
 
78
            adb_unassignAddressResponseType_t *_unassignAddressResponseType = NULL;
 
79
            
 
80
            AXIS2_ENV_CHECK(env, NULL);
 
81
 
 
82
            _unassignAddressResponseType = (adb_unassignAddressResponseType_t *) AXIS2_MALLOC(env->
 
83
                allocator, sizeof(adb_unassignAddressResponseType_t));
 
84
 
 
85
            if(NULL == _unassignAddressResponseType)
 
86
            {
 
87
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
 
88
                return NULL;
 
89
            }
 
90
 
 
91
            memset(_unassignAddressResponseType, 0, sizeof(adb_unassignAddressResponseType_t));
 
92
 
 
93
            _unassignAddressResponseType->property_correlationId  = NULL;
 
94
                  _unassignAddressResponseType->is_valid_correlationId  = AXIS2_FALSE;
 
95
            _unassignAddressResponseType->property_userId  = NULL;
 
96
                  _unassignAddressResponseType->is_valid_userId  = AXIS2_FALSE;
 
97
            _unassignAddressResponseType->property_statusMessage  = NULL;
 
98
                  _unassignAddressResponseType->is_valid_statusMessage  = AXIS2_FALSE;
 
99
            _unassignAddressResponseType->is_valid_return  = AXIS2_FALSE;
 
100
            
 
101
 
 
102
            return _unassignAddressResponseType;
 
103
        }
 
104
 
 
105
        axis2_status_t AXIS2_CALL
 
106
        adb_unassignAddressResponseType_free (
 
107
                adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
108
                const axutil_env_t *env)
 
109
        {
 
110
            
 
111
 
 
112
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
113
            AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
114
 
 
115
            adb_unassignAddressResponseType_reset_correlationId(_unassignAddressResponseType, env);
 
116
            adb_unassignAddressResponseType_reset_userId(_unassignAddressResponseType, env);
 
117
            adb_unassignAddressResponseType_reset_statusMessage(_unassignAddressResponseType, env);
 
118
            adb_unassignAddressResponseType_reset_return(_unassignAddressResponseType, env);
 
119
            
 
120
 
 
121
            if(_unassignAddressResponseType)
 
122
            {
 
123
                AXIS2_FREE(env->allocator, _unassignAddressResponseType);
 
124
                _unassignAddressResponseType = NULL;
 
125
            }
 
126
            return AXIS2_SUCCESS;
 
127
        }
 
128
 
 
129
 
 
130
        
 
131
 
 
132
        axis2_status_t AXIS2_CALL
 
133
        adb_unassignAddressResponseType_deserialize(
 
134
                adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
135
                const axutil_env_t *env,
 
136
                axiom_node_t **dp_parent,
 
137
                axis2_bool_t *dp_is_early_node_valid,
 
138
                axis2_bool_t dont_care_minoccurs)
 
139
        {
 
140
          axiom_node_t *parent = *dp_parent;
 
141
          
 
142
          axis2_status_t status = AXIS2_SUCCESS;
 
143
           
 
144
             axis2_char_t* text_value = NULL;
 
145
             axutil_qname_t *qname = NULL;
 
146
          
 
147
            axutil_qname_t *element_qname = NULL; 
 
148
            
 
149
               axiom_node_t *first_node = NULL;
 
150
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
 
151
               axiom_node_t *current_node = NULL;
 
152
               axiom_element_t *current_element = NULL;
 
153
            
 
154
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
155
            AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
156
 
 
157
            
 
158
              
 
159
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
 
160
              {
 
161
                  parent = axiom_node_get_next_sibling(parent, env);
 
162
              }
 
163
              if (NULL == parent)
 
164
              {
 
165
                /* This should be checked before everything */
 
166
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
 
167
                            "Failed in building adb object for unassignAddressResponseType : "
 
168
                            "NULL elemenet can not be passed to deserialize");
 
169
                return AXIS2_FAILURE;
 
170
              }
 
171
              
 
172
                      
 
173
                      first_node = axiom_node_get_first_child(parent, env);
 
174
                      
 
175
                    
 
176
 
 
177
                     
 
178
                     /*
 
179
                      * building correlationId element
 
180
                      */
 
181
                     
 
182
                     
 
183
                     
 
184
                                   current_node = first_node;
 
185
                                   is_early_node_valid = AXIS2_FALSE;
 
186
                                   
 
187
                                   
 
188
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
189
                                    {
 
190
                                        current_node = axiom_node_get_next_sibling(current_node, env);
 
191
                                    }
 
192
                                    if(current_node != NULL)
 
193
                                    {
 
194
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
195
                                        qname = axiom_element_get_qname(current_element, env, current_node);
 
196
                                    }
 
197
                                   
 
198
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
 
199
                                 
 
200
 
 
201
                           if ( 
 
202
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
203
                           {
 
204
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
205
                              {
 
206
                                is_early_node_valid = AXIS2_TRUE;
 
207
                              }
 
208
                              
 
209
                                 
 
210
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
211
                                      if(text_value != NULL)
 
212
                                      {
 
213
                                            status = adb_unassignAddressResponseType_set_correlationId(_unassignAddressResponseType, env,
 
214
                                                               text_value);
 
215
                                      }
 
216
                                      
 
217
                                      else
 
218
                                      {
 
219
                                            /*
 
220
                                             * axis2_qname_t *qname = NULL;
 
221
                                             * axiom_attribute_t *the_attri = NULL;
 
222
                                             * 
 
223
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
 
224
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
 
225
                                             */
 
226
                                            /* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
 
227
 
 
228
                                            axiom_attribute_t *the_attri = NULL;
 
229
                                            axis2_char_t *attrib_text = NULL;
 
230
                                            axutil_hash_t *attribute_hash = NULL;
 
231
 
 
232
                                            attribute_hash = axiom_element_get_all_attributes(current_element, env);
 
233
 
 
234
                                            attrib_text = NULL;
 
235
                                            if(attribute_hash)
 
236
                                            {
 
237
                                                 axutil_hash_index_t *hi;
 
238
                                                 void *val;
 
239
                                                 const void *key;
 
240
                                        
 
241
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
 
242
                                                 {
 
243
                                                     axutil_hash_this(hi, &key, NULL, &val);
 
244
                                                     
 
245
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
 
246
                                                     {
 
247
                                                         the_attri = (axiom_attribute_t*)val;
 
248
                                                         break;
 
249
                                                     }
 
250
                                                 }
 
251
                                            }
 
252
 
 
253
                                            if(the_attri)
 
254
                                            {
 
255
                                                attrib_text = axiom_attribute_get_value(the_attri, env);
 
256
                                            }
 
257
                                            else
 
258
                                            {
 
259
                                                /* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
 
260
                                                attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
 
261
                                            }
 
262
 
 
263
                                            if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
 
264
                                            {
 
265
                                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element correlationId");
 
266
                                                status = AXIS2_FAILURE;
 
267
                                            }
 
268
                                            else
 
269
                                            {
 
270
                                                /* after all, we found this is a empty string */
 
271
                                                status = adb_unassignAddressResponseType_set_correlationId(_unassignAddressResponseType, env,
 
272
                                                                   "");
 
273
                                            }
 
274
                                      }
 
275
                                      
 
276
                                 if(AXIS2_FAILURE ==  status)
 
277
                                 {
 
278
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
 
279
                                     if(element_qname)
 
280
                                     {
 
281
                                         axutil_qname_free(element_qname, env);
 
282
                                     }
 
283
                                     return AXIS2_FAILURE;
 
284
                                 }
 
285
                              }
 
286
                           
 
287
                  if(element_qname)
 
288
                  {
 
289
                     axutil_qname_free(element_qname, env);
 
290
                     element_qname = NULL;
 
291
                  }
 
292
                 
 
293
 
 
294
                     
 
295
                     /*
 
296
                      * building userId element
 
297
                      */
 
298
                     
 
299
                     
 
300
                     
 
301
                                    /*
 
302
                                     * because elements are ordered this works fine
 
303
                                     */
 
304
                                  
 
305
                                   
 
306
                                   if(current_node != NULL && is_early_node_valid)
 
307
                                   {
 
308
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
309
                                       
 
310
                                       
 
311
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
312
                                        {
 
313
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
314
                                        }
 
315
                                        if(current_node != NULL)
 
316
                                        {
 
317
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
318
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
319
                                        }
 
320
                                       
 
321
                                   }
 
322
                                   is_early_node_valid = AXIS2_FALSE;
 
323
                                 
 
324
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
 
325
                                 
 
326
 
 
327
                           if ( 
 
328
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
329
                           {
 
330
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
331
                              {
 
332
                                is_early_node_valid = AXIS2_TRUE;
 
333
                              }
 
334
                              
 
335
                                 
 
336
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
337
                                      if(text_value != NULL)
 
338
                                      {
 
339
                                            status = adb_unassignAddressResponseType_set_userId(_unassignAddressResponseType, env,
 
340
                                                               text_value);
 
341
                                      }
 
342
                                      
 
343
                                      else
 
344
                                      {
 
345
                                            /*
 
346
                                             * axis2_qname_t *qname = NULL;
 
347
                                             * axiom_attribute_t *the_attri = NULL;
 
348
                                             * 
 
349
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
 
350
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
 
351
                                             */
 
352
                                            /* currently thereis a bug in the axiom_element_get_attribute, so we have to go to this bad method */
 
353
 
 
354
                                            axiom_attribute_t *the_attri = NULL;
 
355
                                            axis2_char_t *attrib_text = NULL;
 
356
                                            axutil_hash_t *attribute_hash = NULL;
 
357
 
 
358
                                            attribute_hash = axiom_element_get_all_attributes(current_element, env);
 
359
 
 
360
                                            attrib_text = NULL;
 
361
                                            if(attribute_hash)
 
362
                                            {
 
363
                                                 axutil_hash_index_t *hi;
 
364
                                                 void *val;
 
365
                                                 const void *key;
 
366
                                        
 
367
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
 
368
                                                 {
 
369
                                                     axutil_hash_this(hi, &key, NULL, &val);
 
370
                                                     
 
371
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
 
372
                                                     {
 
373
                                                         the_attri = (axiom_attribute_t*)val;
 
374
                                                         break;
 
375
                                                     }
 
376
                                                 }
 
377
                                            }
 
378
 
 
379
                                            if(the_attri)
 
380
                                            {
 
381
                                                attrib_text = axiom_attribute_get_value(the_attri, env);
 
382
                                            }
 
383
                                            else
 
384
                                            {
 
385
                                                /* this is hoping that attribute is stored in "http://www.w3.org/2001/XMLSchema-instance", this happnes when name is in default namespace */
 
386
                                                attrib_text = axiom_element_get_attribute_value_by_name(current_element, env, "nil");
 
387
                                            }
 
388
 
 
389
                                            if(attrib_text && 0 == axutil_strcmp(attrib_text, "1"))
 
390
                                            {
 
391
                                                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element userId");
 
392
                                                status = AXIS2_FAILURE;
 
393
                                            }
 
394
                                            else
 
395
                                            {
 
396
                                                /* after all, we found this is a empty string */
 
397
                                                status = adb_unassignAddressResponseType_set_userId(_unassignAddressResponseType, env,
 
398
                                                                   "");
 
399
                                            }
 
400
                                      }
 
401
                                      
 
402
                                 if(AXIS2_FAILURE ==  status)
 
403
                                 {
 
404
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
 
405
                                     if(element_qname)
 
406
                                     {
 
407
                                         axutil_qname_free(element_qname, env);
 
408
                                     }
 
409
                                     return AXIS2_FAILURE;
 
410
                                 }
 
411
                              }
 
412
                           
 
413
                  if(element_qname)
 
414
                  {
 
415
                     axutil_qname_free(element_qname, env);
 
416
                     element_qname = NULL;
 
417
                  }
 
418
                 
 
419
 
 
420
                     
 
421
                     /*
 
422
                      * building statusMessage element
 
423
                      */
 
424
                     
 
425
                     
 
426
                     
 
427
                                    /*
 
428
                                     * because elements are ordered this works fine
 
429
                                     */
 
430
                                  
 
431
                                   
 
432
                                   if(current_node != NULL && is_early_node_valid)
 
433
                                   {
 
434
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
435
                                       
 
436
                                       
 
437
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
438
                                        {
 
439
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
440
                                        }
 
441
                                        if(current_node != NULL)
 
442
                                        {
 
443
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
444
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
445
                                        }
 
446
                                       
 
447
                                   }
 
448
                                   is_early_node_valid = AXIS2_FALSE;
 
449
                                 
 
450
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
 
451
                                 
 
452
 
 
453
                           if ( 
 
454
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
455
                           {
 
456
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
457
                              {
 
458
                                is_early_node_valid = AXIS2_TRUE;
 
459
                              }
 
460
                              
 
461
                                 
 
462
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
463
                                      if(text_value != NULL)
 
464
                                      {
 
465
                                            status = adb_unassignAddressResponseType_set_statusMessage(_unassignAddressResponseType, env,
 
466
                                                               text_value);
 
467
                                      }
 
468
                                      
 
469
                                 if(AXIS2_FAILURE ==  status)
 
470
                                 {
 
471
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
 
472
                                     if(element_qname)
 
473
                                     {
 
474
                                         axutil_qname_free(element_qname, env);
 
475
                                     }
 
476
                                     return AXIS2_FAILURE;
 
477
                                 }
 
478
                              }
 
479
                           
 
480
                  if(element_qname)
 
481
                  {
 
482
                     axutil_qname_free(element_qname, env);
 
483
                     element_qname = NULL;
 
484
                  }
 
485
                 
 
486
 
 
487
                     
 
488
                     /*
 
489
                      * building return element
 
490
                      */
 
491
                     
 
492
                     
 
493
                     
 
494
                                    /*
 
495
                                     * because elements are ordered this works fine
 
496
                                     */
 
497
                                  
 
498
                                   
 
499
                                   if(current_node != NULL && is_early_node_valid)
 
500
                                   {
 
501
                                       current_node = axiom_node_get_next_sibling(current_node, env);
 
502
                                       
 
503
                                       
 
504
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
505
                                        {
 
506
                                            current_node = axiom_node_get_next_sibling(current_node, env);
 
507
                                        }
 
508
                                        if(current_node != NULL)
 
509
                                        {
 
510
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
511
                                            qname = axiom_element_get_qname(current_element, env, current_node);
 
512
                                        }
 
513
                                       
 
514
                                   }
 
515
                                   is_early_node_valid = AXIS2_FALSE;
 
516
                                 
 
517
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
 
518
                                 
 
519
 
 
520
                           if ( 
 
521
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
522
                           {
 
523
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
524
                              {
 
525
                                is_early_node_valid = AXIS2_TRUE;
 
526
                              }
 
527
                              
 
528
                                 
 
529
                                      text_value = axiom_element_get_text(current_element, env, current_node);
 
530
                                      if(text_value != NULL)
 
531
                                      {
 
532
                                            if (!axutil_strcasecmp(text_value , "true"))
 
533
                                            {
 
534
                                                status = adb_unassignAddressResponseType_set_return(_unassignAddressResponseType, env,
 
535
                                                                 AXIS2_TRUE);
 
536
                                            }
 
537
                                            else
 
538
                                            {
 
539
                                                status = adb_unassignAddressResponseType_set_return(_unassignAddressResponseType, env,
 
540
                                                                      AXIS2_FALSE);
 
541
                                            }
 
542
                                      }
 
543
                                      
 
544
                                      else
 
545
                                      {
 
546
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
 
547
                                          status = AXIS2_FAILURE;
 
548
                                      }
 
549
                                      
 
550
                                 if(AXIS2_FAILURE ==  status)
 
551
                                 {
 
552
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
 
553
                                     if(element_qname)
 
554
                                     {
 
555
                                         axutil_qname_free(element_qname, env);
 
556
                                     }
 
557
                                     return AXIS2_FAILURE;
 
558
                                 }
 
559
                              }
 
560
                           
 
561
                  if(element_qname)
 
562
                  {
 
563
                     axutil_qname_free(element_qname, env);
 
564
                     element_qname = NULL;
 
565
                  }
 
566
                 
 
567
          return status;
 
568
       }
 
569
 
 
570
          axis2_bool_t AXIS2_CALL
 
571
          adb_unassignAddressResponseType_is_particle()
 
572
          {
 
573
            
 
574
                 return AXIS2_FALSE;
 
575
              
 
576
          }
 
577
 
 
578
 
 
579
          void AXIS2_CALL
 
580
          adb_unassignAddressResponseType_declare_parent_namespaces(
 
581
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
582
                    const axutil_env_t *env, axiom_element_t *parent_element,
 
583
                    axutil_hash_t *namespaces, int *next_ns_index)
 
584
          {
 
585
            
 
586
                  /* Here this is an empty function, Nothing to declare */
 
587
                 
 
588
          }
 
589
 
 
590
        
 
591
        
 
592
        axiom_node_t* AXIS2_CALL
 
593
        adb_unassignAddressResponseType_serialize(
 
594
                adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
595
                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)
 
596
        {
 
597
            
 
598
            
 
599
             axis2_char_t *string_to_stream;
 
600
            
 
601
         
 
602
         axiom_node_t *current_node = NULL;
 
603
         int tag_closed = 0;
 
604
 
 
605
         
 
606
         
 
607
                axiom_namespace_t *ns1 = NULL;
 
608
 
 
609
                axis2_char_t *qname_uri = NULL;
 
610
                axis2_char_t *qname_prefix = NULL;
 
611
                axis2_char_t *p_prefix = NULL;
 
612
                axis2_bool_t ns_already_defined;
 
613
            
 
614
                    axis2_char_t *text_value_1;
 
615
                    axis2_char_t *text_value_1_temp;
 
616
                    
 
617
                    axis2_char_t *text_value_2;
 
618
                    axis2_char_t *text_value_2_temp;
 
619
                    
 
620
                    axis2_char_t *text_value_3;
 
621
                    axis2_char_t *text_value_3_temp;
 
622
                    
 
623
                    axis2_char_t text_value_4[64];
 
624
                    
 
625
               axis2_char_t *start_input_str = NULL;
 
626
               axis2_char_t *end_input_str = NULL;
 
627
               unsigned int start_input_str_len = 0;
 
628
               unsigned int end_input_str_len = 0;
 
629
            
 
630
            
 
631
               axiom_data_source_t *data_source = NULL;
 
632
               axutil_stream_t *stream = NULL;
 
633
 
 
634
            
 
635
 
 
636
            AXIS2_ENV_CHECK(env, NULL);
 
637
            AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, NULL);
 
638
            
 
639
            
 
640
                    current_node = parent;
 
641
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
 
642
                    if (!data_source)
 
643
                        return NULL;
 
644
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
 
645
                    if (!stream)
 
646
                        return NULL;
 
647
                  
 
648
            if(!parent_tag_closed)
 
649
            {
 
650
            
 
651
              string_to_stream = ">"; 
 
652
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
 
653
              tag_closed = 1;
 
654
            
 
655
            }
 
656
            
 
657
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
658
                       {
 
659
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
660
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
661
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
662
                           
 
663
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
664
                                            "http://eucalyptus.ucsb.edu/",
 
665
                                            p_prefix));
 
666
                       }
 
667
                      
 
668
 
 
669
                   if (!_unassignAddressResponseType->is_valid_correlationId)
 
670
                   {
 
671
                      
 
672
                           /* no need to complain for minoccurs=0 element */
 
673
                            
 
674
                          
 
675
                   }
 
676
                   else
 
677
                   {
 
678
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
679
                                 (4 + axutil_strlen(p_prefix) + 
 
680
                                  axutil_strlen("correlationId"))); 
 
681
                                 
 
682
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
683
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
684
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
 
685
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
686
                                  
 
687
                     
 
688
 
 
689
                   
 
690
                   
 
691
                     
 
692
                     /*
 
693
                      * parsing correlationId element
 
694
                      */
 
695
 
 
696
                    
 
697
                    
 
698
                            sprintf(start_input_str, "<%s%scorrelationId>",
 
699
                                 p_prefix?p_prefix:"",
 
700
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
701
                            
 
702
                        start_input_str_len = axutil_strlen(start_input_str);
 
703
                        sprintf(end_input_str, "</%s%scorrelationId>",
 
704
                                 p_prefix?p_prefix:"",
 
705
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
706
                        end_input_str_len = axutil_strlen(end_input_str);
 
707
                    
 
708
                           text_value_1 = _unassignAddressResponseType->property_correlationId;
 
709
                           
 
710
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
711
                           
 
712
                            
 
713
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
 
714
                           if (text_value_1_temp)
 
715
                           {
 
716
                               axutil_stream_write(stream, env, text_value_1_temp, axutil_strlen(text_value_1_temp));
 
717
                               AXIS2_FREE(env->allocator, text_value_1_temp);
 
718
                           }
 
719
                           else
 
720
                           {
 
721
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
 
722
                           }
 
723
                           
 
724
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
725
                           
 
726
                     
 
727
                     AXIS2_FREE(env->allocator,start_input_str);
 
728
                     AXIS2_FREE(env->allocator,end_input_str);
 
729
                 } 
 
730
 
 
731
                 
 
732
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
733
                       {
 
734
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
735
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
736
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
737
                           
 
738
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
739
                                            "http://eucalyptus.ucsb.edu/",
 
740
                                            p_prefix));
 
741
                       }
 
742
                      
 
743
 
 
744
                   if (!_unassignAddressResponseType->is_valid_userId)
 
745
                   {
 
746
                      
 
747
                           /* no need to complain for minoccurs=0 element */
 
748
                            
 
749
                          
 
750
                   }
 
751
                   else
 
752
                   {
 
753
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
754
                                 (4 + axutil_strlen(p_prefix) + 
 
755
                                  axutil_strlen("userId"))); 
 
756
                                 
 
757
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
758
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
759
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
 
760
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
761
                                  
 
762
                     
 
763
 
 
764
                   
 
765
                   
 
766
                     
 
767
                     /*
 
768
                      * parsing userId element
 
769
                      */
 
770
 
 
771
                    
 
772
                    
 
773
                            sprintf(start_input_str, "<%s%suserId>",
 
774
                                 p_prefix?p_prefix:"",
 
775
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
776
                            
 
777
                        start_input_str_len = axutil_strlen(start_input_str);
 
778
                        sprintf(end_input_str, "</%s%suserId>",
 
779
                                 p_prefix?p_prefix:"",
 
780
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
781
                        end_input_str_len = axutil_strlen(end_input_str);
 
782
                    
 
783
                           text_value_2 = _unassignAddressResponseType->property_userId;
 
784
                           
 
785
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
786
                           
 
787
                            
 
788
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
 
789
                           if (text_value_2_temp)
 
790
                           {
 
791
                               axutil_stream_write(stream, env, text_value_2_temp, axutil_strlen(text_value_2_temp));
 
792
                               AXIS2_FREE(env->allocator, text_value_2_temp);
 
793
                           }
 
794
                           else
 
795
                           {
 
796
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
 
797
                           }
 
798
                           
 
799
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
800
                           
 
801
                     
 
802
                     AXIS2_FREE(env->allocator,start_input_str);
 
803
                     AXIS2_FREE(env->allocator,end_input_str);
 
804
                 } 
 
805
 
 
806
                 
 
807
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
808
                       {
 
809
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
810
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
811
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
812
                           
 
813
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
814
                                            "http://eucalyptus.ucsb.edu/",
 
815
                                            p_prefix));
 
816
                       }
 
817
                      
 
818
 
 
819
                   if (!_unassignAddressResponseType->is_valid_statusMessage)
 
820
                   {
 
821
                      
 
822
                           /* no need to complain for minoccurs=0 element */
 
823
                            
 
824
                          
 
825
                   }
 
826
                   else
 
827
                   {
 
828
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
829
                                 (4 + axutil_strlen(p_prefix) + 
 
830
                                  axutil_strlen("statusMessage"))); 
 
831
                                 
 
832
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
833
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
834
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
 
835
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
836
                                  
 
837
                     
 
838
 
 
839
                   
 
840
                   
 
841
                     
 
842
                     /*
 
843
                      * parsing statusMessage element
 
844
                      */
 
845
 
 
846
                    
 
847
                    
 
848
                            sprintf(start_input_str, "<%s%sstatusMessage>",
 
849
                                 p_prefix?p_prefix:"",
 
850
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
851
                            
 
852
                        start_input_str_len = axutil_strlen(start_input_str);
 
853
                        sprintf(end_input_str, "</%s%sstatusMessage>",
 
854
                                 p_prefix?p_prefix:"",
 
855
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
856
                        end_input_str_len = axutil_strlen(end_input_str);
 
857
                    
 
858
                           text_value_3 = _unassignAddressResponseType->property_statusMessage;
 
859
                           
 
860
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
861
                           
 
862
                            
 
863
                           text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
 
864
                           if (text_value_3_temp)
 
865
                           {
 
866
                               axutil_stream_write(stream, env, text_value_3_temp, axutil_strlen(text_value_3_temp));
 
867
                               AXIS2_FREE(env->allocator, text_value_3_temp);
 
868
                           }
 
869
                           else
 
870
                           {
 
871
                               axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
 
872
                           }
 
873
                           
 
874
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
875
                           
 
876
                     
 
877
                     AXIS2_FREE(env->allocator,start_input_str);
 
878
                     AXIS2_FREE(env->allocator,end_input_str);
 
879
                 } 
 
880
 
 
881
                 
 
882
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
883
                       {
 
884
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
885
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
886
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
887
                           
 
888
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
889
                                            "http://eucalyptus.ucsb.edu/",
 
890
                                            p_prefix));
 
891
                       }
 
892
                      
 
893
 
 
894
                   if (!_unassignAddressResponseType->is_valid_return)
 
895
                   {
 
896
                      
 
897
                           /* no need to complain for minoccurs=0 element */
 
898
                            
 
899
                          
 
900
                   }
 
901
                   else
 
902
                   {
 
903
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
904
                                 (4 + axutil_strlen(p_prefix) + 
 
905
                                  axutil_strlen("return"))); 
 
906
                                 
 
907
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
908
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
909
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
 
910
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
911
                                  
 
912
                     
 
913
 
 
914
                   
 
915
                   
 
916
                     
 
917
                     /*
 
918
                      * parsing return element
 
919
                      */
 
920
 
 
921
                    
 
922
                    
 
923
                            sprintf(start_input_str, "<%s%sreturn>",
 
924
                                 p_prefix?p_prefix:"",
 
925
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
926
                            
 
927
                        start_input_str_len = axutil_strlen(start_input_str);
 
928
                        sprintf(end_input_str, "</%s%sreturn>",
 
929
                                 p_prefix?p_prefix:"",
 
930
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
931
                        end_input_str_len = axutil_strlen(end_input_str);
 
932
                    
 
933
                           strcpy(text_value_4, (_unassignAddressResponseType->property_return)?"true":"false");
 
934
                           
 
935
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
 
936
                           
 
937
                           axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
 
938
                           
 
939
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
 
940
                           
 
941
                     
 
942
                     AXIS2_FREE(env->allocator,start_input_str);
 
943
                     AXIS2_FREE(env->allocator,end_input_str);
 
944
                 } 
 
945
 
 
946
                 
 
947
 
 
948
            return parent;
 
949
        }
 
950
 
 
951
 
 
952
        
 
953
 
 
954
            /**
 
955
             * getter for correlationId.
 
956
             */
 
957
            axis2_char_t* AXIS2_CALL
 
958
            adb_unassignAddressResponseType_get_correlationId(
 
959
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
960
                    const axutil_env_t *env)
 
961
             {
 
962
                
 
963
                    AXIS2_ENV_CHECK(env, NULL);
 
964
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, NULL);
 
965
                  
 
966
 
 
967
                return _unassignAddressResponseType->property_correlationId;
 
968
             }
 
969
 
 
970
            /**
 
971
             * setter for correlationId
 
972
             */
 
973
            axis2_status_t AXIS2_CALL
 
974
            adb_unassignAddressResponseType_set_correlationId(
 
975
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
976
                    const axutil_env_t *env,
 
977
                    const axis2_char_t*  arg_correlationId)
 
978
             {
 
979
                
 
980
 
 
981
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
982
                AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
983
                
 
984
                if(_unassignAddressResponseType->is_valid_correlationId &&
 
985
                        arg_correlationId == _unassignAddressResponseType->property_correlationId)
 
986
                {
 
987
                    
 
988
                    return AXIS2_SUCCESS; 
 
989
                }
 
990
 
 
991
                adb_unassignAddressResponseType_reset_correlationId(_unassignAddressResponseType, env);
 
992
 
 
993
                
 
994
                if(NULL == arg_correlationId)
 
995
                {
 
996
                    /* We are already done */
 
997
                    return AXIS2_SUCCESS;
 
998
                }
 
999
                _unassignAddressResponseType->property_correlationId = (axis2_char_t *)axutil_strdup(env, arg_correlationId);
 
1000
                        if(NULL == _unassignAddressResponseType->property_correlationId)
 
1001
                        {
 
1002
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for correlationId");
 
1003
                            return AXIS2_FAILURE;
 
1004
                        }
 
1005
                        _unassignAddressResponseType->is_valid_correlationId = AXIS2_TRUE;
 
1006
                    
 
1007
                return AXIS2_SUCCESS;
 
1008
             }
 
1009
 
 
1010
             
 
1011
 
 
1012
           /**
 
1013
            * resetter for correlationId
 
1014
            */
 
1015
           axis2_status_t AXIS2_CALL
 
1016
           adb_unassignAddressResponseType_reset_correlationId(
 
1017
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1018
                   const axutil_env_t *env)
 
1019
           {
 
1020
               int i = 0;
 
1021
               int count = 0;
 
1022
               void *element = NULL;
 
1023
 
 
1024
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1025
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
1026
               
 
1027
 
 
1028
               
 
1029
            
 
1030
                
 
1031
                if(_unassignAddressResponseType->property_correlationId != NULL)
 
1032
                {
 
1033
                   
 
1034
                   
 
1035
                        AXIS2_FREE(env-> allocator, _unassignAddressResponseType->property_correlationId);
 
1036
                     _unassignAddressResponseType->property_correlationId = NULL;
 
1037
                }
 
1038
            
 
1039
                
 
1040
                
 
1041
                _unassignAddressResponseType->is_valid_correlationId = AXIS2_FALSE; 
 
1042
               return AXIS2_SUCCESS;
 
1043
           }
 
1044
 
 
1045
           /**
 
1046
            * Check whether correlationId is nill
 
1047
            */
 
1048
           axis2_bool_t AXIS2_CALL
 
1049
           adb_unassignAddressResponseType_is_correlationId_nil(
 
1050
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1051
                   const axutil_env_t *env)
 
1052
           {
 
1053
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1054
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_TRUE);
 
1055
               
 
1056
               return !_unassignAddressResponseType->is_valid_correlationId;
 
1057
           }
 
1058
 
 
1059
           /**
 
1060
            * Set correlationId to nill (currently the same as reset)
 
1061
            */
 
1062
           axis2_status_t AXIS2_CALL
 
1063
           adb_unassignAddressResponseType_set_correlationId_nil(
 
1064
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1065
                   const axutil_env_t *env)
 
1066
           {
 
1067
               return adb_unassignAddressResponseType_reset_correlationId(_unassignAddressResponseType, env);
 
1068
           }
 
1069
 
 
1070
           
 
1071
 
 
1072
            /**
 
1073
             * getter for userId.
 
1074
             */
 
1075
            axis2_char_t* AXIS2_CALL
 
1076
            adb_unassignAddressResponseType_get_userId(
 
1077
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1078
                    const axutil_env_t *env)
 
1079
             {
 
1080
                
 
1081
                    AXIS2_ENV_CHECK(env, NULL);
 
1082
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, NULL);
 
1083
                  
 
1084
 
 
1085
                return _unassignAddressResponseType->property_userId;
 
1086
             }
 
1087
 
 
1088
            /**
 
1089
             * setter for userId
 
1090
             */
 
1091
            axis2_status_t AXIS2_CALL
 
1092
            adb_unassignAddressResponseType_set_userId(
 
1093
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1094
                    const axutil_env_t *env,
 
1095
                    const axis2_char_t*  arg_userId)
 
1096
             {
 
1097
                
 
1098
 
 
1099
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1100
                AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
1101
                
 
1102
                if(_unassignAddressResponseType->is_valid_userId &&
 
1103
                        arg_userId == _unassignAddressResponseType->property_userId)
 
1104
                {
 
1105
                    
 
1106
                    return AXIS2_SUCCESS; 
 
1107
                }
 
1108
 
 
1109
                adb_unassignAddressResponseType_reset_userId(_unassignAddressResponseType, env);
 
1110
 
 
1111
                
 
1112
                if(NULL == arg_userId)
 
1113
                {
 
1114
                    /* We are already done */
 
1115
                    return AXIS2_SUCCESS;
 
1116
                }
 
1117
                _unassignAddressResponseType->property_userId = (axis2_char_t *)axutil_strdup(env, arg_userId);
 
1118
                        if(NULL == _unassignAddressResponseType->property_userId)
 
1119
                        {
 
1120
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for userId");
 
1121
                            return AXIS2_FAILURE;
 
1122
                        }
 
1123
                        _unassignAddressResponseType->is_valid_userId = AXIS2_TRUE;
 
1124
                    
 
1125
                return AXIS2_SUCCESS;
 
1126
             }
 
1127
 
 
1128
             
 
1129
 
 
1130
           /**
 
1131
            * resetter for userId
 
1132
            */
 
1133
           axis2_status_t AXIS2_CALL
 
1134
           adb_unassignAddressResponseType_reset_userId(
 
1135
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1136
                   const axutil_env_t *env)
 
1137
           {
 
1138
               int i = 0;
 
1139
               int count = 0;
 
1140
               void *element = NULL;
 
1141
 
 
1142
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1143
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
1144
               
 
1145
 
 
1146
               
 
1147
            
 
1148
                
 
1149
                if(_unassignAddressResponseType->property_userId != NULL)
 
1150
                {
 
1151
                   
 
1152
                   
 
1153
                        AXIS2_FREE(env-> allocator, _unassignAddressResponseType->property_userId);
 
1154
                     _unassignAddressResponseType->property_userId = NULL;
 
1155
                }
 
1156
            
 
1157
                
 
1158
                
 
1159
                _unassignAddressResponseType->is_valid_userId = AXIS2_FALSE; 
 
1160
               return AXIS2_SUCCESS;
 
1161
           }
 
1162
 
 
1163
           /**
 
1164
            * Check whether userId is nill
 
1165
            */
 
1166
           axis2_bool_t AXIS2_CALL
 
1167
           adb_unassignAddressResponseType_is_userId_nil(
 
1168
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1169
                   const axutil_env_t *env)
 
1170
           {
 
1171
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1172
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_TRUE);
 
1173
               
 
1174
               return !_unassignAddressResponseType->is_valid_userId;
 
1175
           }
 
1176
 
 
1177
           /**
 
1178
            * Set userId to nill (currently the same as reset)
 
1179
            */
 
1180
           axis2_status_t AXIS2_CALL
 
1181
           adb_unassignAddressResponseType_set_userId_nil(
 
1182
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1183
                   const axutil_env_t *env)
 
1184
           {
 
1185
               return adb_unassignAddressResponseType_reset_userId(_unassignAddressResponseType, env);
 
1186
           }
 
1187
 
 
1188
           
 
1189
 
 
1190
            /**
 
1191
             * getter for statusMessage.
 
1192
             */
 
1193
            axis2_char_t* AXIS2_CALL
 
1194
            adb_unassignAddressResponseType_get_statusMessage(
 
1195
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1196
                    const axutil_env_t *env)
 
1197
             {
 
1198
                
 
1199
                    AXIS2_ENV_CHECK(env, NULL);
 
1200
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, NULL);
 
1201
                  
 
1202
 
 
1203
                return _unassignAddressResponseType->property_statusMessage;
 
1204
             }
 
1205
 
 
1206
            /**
 
1207
             * setter for statusMessage
 
1208
             */
 
1209
            axis2_status_t AXIS2_CALL
 
1210
            adb_unassignAddressResponseType_set_statusMessage(
 
1211
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1212
                    const axutil_env_t *env,
 
1213
                    const axis2_char_t*  arg_statusMessage)
 
1214
             {
 
1215
                
 
1216
 
 
1217
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1218
                AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
1219
                
 
1220
                if(_unassignAddressResponseType->is_valid_statusMessage &&
 
1221
                        arg_statusMessage == _unassignAddressResponseType->property_statusMessage)
 
1222
                {
 
1223
                    
 
1224
                    return AXIS2_SUCCESS; 
 
1225
                }
 
1226
 
 
1227
                adb_unassignAddressResponseType_reset_statusMessage(_unassignAddressResponseType, env);
 
1228
 
 
1229
                
 
1230
                if(NULL == arg_statusMessage)
 
1231
                {
 
1232
                    /* We are already done */
 
1233
                    return AXIS2_SUCCESS;
 
1234
                }
 
1235
                _unassignAddressResponseType->property_statusMessage = (axis2_char_t *)axutil_strdup(env, arg_statusMessage);
 
1236
                        if(NULL == _unassignAddressResponseType->property_statusMessage)
 
1237
                        {
 
1238
                            AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error allocating memeory for statusMessage");
 
1239
                            return AXIS2_FAILURE;
 
1240
                        }
 
1241
                        _unassignAddressResponseType->is_valid_statusMessage = AXIS2_TRUE;
 
1242
                    
 
1243
                return AXIS2_SUCCESS;
 
1244
             }
 
1245
 
 
1246
             
 
1247
 
 
1248
           /**
 
1249
            * resetter for statusMessage
 
1250
            */
 
1251
           axis2_status_t AXIS2_CALL
 
1252
           adb_unassignAddressResponseType_reset_statusMessage(
 
1253
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1254
                   const axutil_env_t *env)
 
1255
           {
 
1256
               int i = 0;
 
1257
               int count = 0;
 
1258
               void *element = NULL;
 
1259
 
 
1260
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1261
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
1262
               
 
1263
 
 
1264
               
 
1265
            
 
1266
                
 
1267
                if(_unassignAddressResponseType->property_statusMessage != NULL)
 
1268
                {
 
1269
                   
 
1270
                   
 
1271
                        AXIS2_FREE(env-> allocator, _unassignAddressResponseType->property_statusMessage);
 
1272
                     _unassignAddressResponseType->property_statusMessage = NULL;
 
1273
                }
 
1274
            
 
1275
                
 
1276
                
 
1277
                _unassignAddressResponseType->is_valid_statusMessage = AXIS2_FALSE; 
 
1278
               return AXIS2_SUCCESS;
 
1279
           }
 
1280
 
 
1281
           /**
 
1282
            * Check whether statusMessage is nill
 
1283
            */
 
1284
           axis2_bool_t AXIS2_CALL
 
1285
           adb_unassignAddressResponseType_is_statusMessage_nil(
 
1286
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1287
                   const axutil_env_t *env)
 
1288
           {
 
1289
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1290
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_TRUE);
 
1291
               
 
1292
               return !_unassignAddressResponseType->is_valid_statusMessage;
 
1293
           }
 
1294
 
 
1295
           /**
 
1296
            * Set statusMessage to nill (currently the same as reset)
 
1297
            */
 
1298
           axis2_status_t AXIS2_CALL
 
1299
           adb_unassignAddressResponseType_set_statusMessage_nil(
 
1300
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1301
                   const axutil_env_t *env)
 
1302
           {
 
1303
               return adb_unassignAddressResponseType_reset_statusMessage(_unassignAddressResponseType, env);
 
1304
           }
 
1305
 
 
1306
           
 
1307
 
 
1308
            /**
 
1309
             * getter for return.
 
1310
             */
 
1311
            axis2_bool_t AXIS2_CALL
 
1312
            adb_unassignAddressResponseType_get_return(
 
1313
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1314
                    const axutil_env_t *env)
 
1315
             {
 
1316
                
 
1317
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
 
1318
                    AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, (axis2_bool_t)0);
 
1319
                  
 
1320
 
 
1321
                return _unassignAddressResponseType->property_return;
 
1322
             }
 
1323
 
 
1324
            /**
 
1325
             * setter for return
 
1326
             */
 
1327
            axis2_status_t AXIS2_CALL
 
1328
            adb_unassignAddressResponseType_set_return(
 
1329
                    adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1330
                    const axutil_env_t *env,
 
1331
                    axis2_bool_t  arg_return)
 
1332
             {
 
1333
                
 
1334
 
 
1335
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1336
                AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
1337
                
 
1338
                if(_unassignAddressResponseType->is_valid_return &&
 
1339
                        arg_return == _unassignAddressResponseType->property_return)
 
1340
                {
 
1341
                    
 
1342
                    return AXIS2_SUCCESS; 
 
1343
                }
 
1344
 
 
1345
                adb_unassignAddressResponseType_reset_return(_unassignAddressResponseType, env);
 
1346
 
 
1347
                _unassignAddressResponseType->property_return = arg_return;
 
1348
                        _unassignAddressResponseType->is_valid_return = AXIS2_TRUE;
 
1349
                    
 
1350
                return AXIS2_SUCCESS;
 
1351
             }
 
1352
 
 
1353
             
 
1354
 
 
1355
           /**
 
1356
            * resetter for return
 
1357
            */
 
1358
           axis2_status_t AXIS2_CALL
 
1359
           adb_unassignAddressResponseType_reset_return(
 
1360
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1361
                   const axutil_env_t *env)
 
1362
           {
 
1363
               int i = 0;
 
1364
               int count = 0;
 
1365
               void *element = NULL;
 
1366
 
 
1367
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
1368
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_FAILURE);
 
1369
               
 
1370
 
 
1371
               _unassignAddressResponseType->is_valid_return = AXIS2_FALSE; 
 
1372
               return AXIS2_SUCCESS;
 
1373
           }
 
1374
 
 
1375
           /**
 
1376
            * Check whether return is nill
 
1377
            */
 
1378
           axis2_bool_t AXIS2_CALL
 
1379
           adb_unassignAddressResponseType_is_return_nil(
 
1380
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1381
                   const axutil_env_t *env)
 
1382
           {
 
1383
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
1384
               AXIS2_PARAM_CHECK(env->error, _unassignAddressResponseType, AXIS2_TRUE);
 
1385
               
 
1386
               return !_unassignAddressResponseType->is_valid_return;
 
1387
           }
 
1388
 
 
1389
           /**
 
1390
            * Set return to nill (currently the same as reset)
 
1391
            */
 
1392
           axis2_status_t AXIS2_CALL
 
1393
           adb_unassignAddressResponseType_set_return_nil(
 
1394
                   adb_unassignAddressResponseType_t* _unassignAddressResponseType,
 
1395
                   const axutil_env_t *env)
 
1396
           {
 
1397
               return adb_unassignAddressResponseType_reset_return(_unassignAddressResponseType, env);
 
1398
           }
 
1399
 
 
1400
           
 
1401