← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cluster/generated/adb_stopNetworkResponseType.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_stopNetworkResponseType.c
8
8
         */
9
9
 
10
10
        #include "adb_stopNetworkResponseType.h"
11
 
 
 
11
        
12
12
                /*
13
13
                 * This type was generated from the piece of schema that had
14
14
                 * name = stopNetworkResponseType
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_stopNetworkResponseType
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
            
48
48
        };
49
49
 
50
50
 
51
51
       /************************* Private Function prototypes ********************************/
52
 
 
 
52
        
53
53
 
54
54
                axis2_status_t AXIS2_CALL
55
55
                adb_stopNetworkResponseType_set_correlationId_nil(
56
56
                        adb_stopNetworkResponseType_t* _stopNetworkResponseType,
57
57
                        const axutil_env_t *env);
58
 
 
 
58
            
59
59
 
60
60
                axis2_status_t AXIS2_CALL
61
61
                adb_stopNetworkResponseType_set_userId_nil(
62
62
                        adb_stopNetworkResponseType_t* _stopNetworkResponseType,
63
63
                        const axutil_env_t *env);
64
 
 
 
64
            
65
65
 
66
66
                axis2_status_t AXIS2_CALL
67
67
                adb_stopNetworkResponseType_set_return_nil(
68
68
                        adb_stopNetworkResponseType_t* _stopNetworkResponseType,
69
69
                        const axutil_env_t *env);
70
 
 
 
70
            
71
71
 
72
72
 
73
73
       /************************* Function Implmentations ********************************/
76
76
            const axutil_env_t *env)
77
77
        {
78
78
            adb_stopNetworkResponseType_t *_stopNetworkResponseType = NULL;
79
 
 
 
79
            
80
80
            AXIS2_ENV_CHECK(env, NULL);
81
81
 
82
82
            _stopNetworkResponseType = (adb_stopNetworkResponseType_t *) AXIS2_MALLOC(env->
97
97
            _stopNetworkResponseType->property_statusMessage  = NULL;
98
98
                  _stopNetworkResponseType->is_valid_statusMessage  = AXIS2_FALSE;
99
99
            _stopNetworkResponseType->is_valid_return  = AXIS2_FALSE;
100
 
 
 
100
            
101
101
 
102
102
            return _stopNetworkResponseType;
103
103
        }
107
107
                adb_stopNetworkResponseType_t* _stopNetworkResponseType,
108
108
                const axutil_env_t *env)
109
109
        {
110
 
 
 
110
            
111
111
 
112
112
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
113
113
            AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
116
116
            adb_stopNetworkResponseType_reset_userId(_stopNetworkResponseType, env);
117
117
            adb_stopNetworkResponseType_reset_statusMessage(_stopNetworkResponseType, env);
118
118
            adb_stopNetworkResponseType_reset_return(_stopNetworkResponseType, env);
119
 
 
 
119
            
120
120
 
121
121
            if(_stopNetworkResponseType)
122
122
            {
127
127
        }
128
128
 
129
129
 
130
 
 
 
130
        
131
131
 
132
132
        axis2_status_t AXIS2_CALL
133
133
        adb_stopNetworkResponseType_deserialize(
138
138
                axis2_bool_t dont_care_minoccurs)
139
139
        {
140
140
          axiom_node_t *parent = *dp_parent;
141
 
 
 
141
          
142
142
          axis2_status_t status = AXIS2_SUCCESS;
143
 
 
 
143
           
144
144
             axis2_char_t* text_value = NULL;
145
145
             axutil_qname_t *qname = NULL;
146
 
 
147
 
            axutil_qname_t *element_qname = NULL;
148
 
 
 
146
          
 
147
            axutil_qname_t *element_qname = NULL; 
 
148
            
149
149
               axiom_node_t *first_node = NULL;
150
150
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
151
151
               axiom_node_t *current_node = NULL;
152
152
               axiom_element_t *current_element = NULL;
153
 
 
 
153
            
154
154
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
155
155
            AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
156
156
 
157
 
 
158
 
 
 
157
            
 
158
              
159
159
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
160
160
              {
161
161
                  parent = axiom_node_get_next_sibling(parent, env);
163
163
              if (NULL == parent)
164
164
              {
165
165
                /* This should be checked before everything */
166
 
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
 
166
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
167
167
                            "Failed in building adb object for stopNetworkResponseType : "
168
168
                            "NULL elemenet can not be passed to deserialize");
169
169
                return AXIS2_FAILURE;
170
170
              }
171
 
 
172
 
 
 
171
              
 
172
                      
173
173
                      first_node = axiom_node_get_first_child(parent, env);
174
 
 
175
 
 
176
 
 
177
 
 
 
174
                      
 
175
                    
 
176
 
 
177
                     
178
178
                     /*
179
179
                      * building correlationId element
180
180
                      */
181
 
 
182
 
 
183
 
 
 
181
                     
 
182
                     
 
183
                     
184
184
                                   current_node = first_node;
185
185
                                   is_early_node_valid = AXIS2_FALSE;
186
 
 
187
 
 
 
186
                                   
 
187
                                   
188
188
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
189
189
                                    {
190
190
                                        current_node = axiom_node_get_next_sibling(current_node, env);
194
194
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
195
195
                                        qname = axiom_element_get_qname(current_element, env, current_node);
196
196
                                    }
197
 
 
 
197
                                   
198
198
                                 element_qname = axutil_qname_create(env, "correlationId", "http://eucalyptus.ucsb.edu/", NULL);
199
 
 
200
 
 
201
 
                           if (
 
199
                                 
 
200
 
 
201
                           if ( 
202
202
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
203
203
                           {
204
204
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
205
205
                              {
206
206
                                is_early_node_valid = AXIS2_TRUE;
207
207
                              }
208
 
 
209
 
 
 
208
                              
 
209
                                 
210
210
                                      text_value = axiom_element_get_text(current_element, env, current_node);
211
211
                                      if(text_value != NULL)
212
212
                                      {
213
213
                                            status = adb_stopNetworkResponseType_set_correlationId(_stopNetworkResponseType, env,
214
214
                                                               text_value);
215
215
                                      }
216
 
 
 
216
                                      
217
217
                                      else
218
218
                                      {
219
219
                                            /*
220
220
                                             * axis2_qname_t *qname = NULL;
221
221
                                             * axiom_attribute_t *the_attri = NULL;
222
 
                                             *
 
222
                                             * 
223
223
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
224
224
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
225
225
                                             */
237
237
                                                 axutil_hash_index_t *hi;
238
238
                                                 void *val;
239
239
                                                 const void *key;
240
 
 
241
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
240
                                        
 
241
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
242
242
                                                 {
243
243
                                                     axutil_hash_this(hi, &key, NULL, &val);
244
 
 
 
244
                                                     
245
245
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
246
246
                                                     {
247
247
                                                         the_attri = (axiom_attribute_t*)val;
272
272
                                                                   "");
273
273
                                            }
274
274
                                      }
275
 
 
 
275
                                      
276
276
                                 if(AXIS2_FAILURE ==  status)
277
277
                                 {
278
278
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for correlationId ");
283
283
                                     return AXIS2_FAILURE;
284
284
                                 }
285
285
                              }
286
 
 
 
286
                           
287
287
                  if(element_qname)
288
288
                  {
289
289
                     axutil_qname_free(element_qname, env);
290
290
                     element_qname = NULL;
291
291
                  }
292
 
 
293
 
 
294
 
 
 
292
                 
 
293
 
 
294
                     
295
295
                     /*
296
296
                      * building userId element
297
297
                      */
298
 
 
299
 
 
300
 
 
 
298
                     
 
299
                     
 
300
                     
301
301
                                    /*
302
302
                                     * because elements are ordered this works fine
303
303
                                     */
304
 
 
305
 
 
 
304
                                  
 
305
                                   
306
306
                                   if(current_node != NULL && is_early_node_valid)
307
307
                                   {
308
308
                                       current_node = axiom_node_get_next_sibling(current_node, env);
309
 
 
310
 
 
 
309
                                       
 
310
                                       
311
311
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
312
312
                                        {
313
313
                                            current_node = axiom_node_get_next_sibling(current_node, env);
317
317
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
318
318
                                            qname = axiom_element_get_qname(current_element, env, current_node);
319
319
                                        }
320
 
 
 
320
                                       
321
321
                                   }
322
322
                                   is_early_node_valid = AXIS2_FALSE;
323
 
 
 
323
                                 
324
324
                                 element_qname = axutil_qname_create(env, "userId", "http://eucalyptus.ucsb.edu/", NULL);
325
 
 
326
 
 
327
 
                           if (
 
325
                                 
 
326
 
 
327
                           if ( 
328
328
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
329
329
                           {
330
330
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
331
331
                              {
332
332
                                is_early_node_valid = AXIS2_TRUE;
333
333
                              }
334
 
 
335
 
 
 
334
                              
 
335
                                 
336
336
                                      text_value = axiom_element_get_text(current_element, env, current_node);
337
337
                                      if(text_value != NULL)
338
338
                                      {
339
339
                                            status = adb_stopNetworkResponseType_set_userId(_stopNetworkResponseType, env,
340
340
                                                               text_value);
341
341
                                      }
342
 
 
 
342
                                      
343
343
                                      else
344
344
                                      {
345
345
                                            /*
346
346
                                             * axis2_qname_t *qname = NULL;
347
347
                                             * axiom_attribute_t *the_attri = NULL;
348
 
                                             *
 
348
                                             * 
349
349
                                             * qname = axutil_qname_create(env, "nil", "http://www.w3.org/2001/XMLSchema-instance", "xsi");
350
350
                                             * the_attri = axiom_element_get_attribute(current_element, env, qname);
351
351
                                             */
363
363
                                                 axutil_hash_index_t *hi;
364
364
                                                 void *val;
365
365
                                                 const void *key;
366
 
 
367
 
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi))
 
366
                                        
 
367
                                                 for (hi = axutil_hash_first(attribute_hash, env); hi; hi = axutil_hash_next(env, hi)) 
368
368
                                                 {
369
369
                                                     axutil_hash_this(hi, &key, NULL, &val);
370
 
 
 
370
                                                     
371
371
                                                     if(strstr((axis2_char_t*)key, "nil|http://www.w3.org/2001/XMLSchema-instance"))
372
372
                                                     {
373
373
                                                         the_attri = (axiom_attribute_t*)val;
398
398
                                                                   "");
399
399
                                            }
400
400
                                      }
401
 
 
 
401
                                      
402
402
                                 if(AXIS2_FAILURE ==  status)
403
403
                                 {
404
404
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for userId ");
409
409
                                     return AXIS2_FAILURE;
410
410
                                 }
411
411
                              }
412
 
 
 
412
                           
413
413
                  if(element_qname)
414
414
                  {
415
415
                     axutil_qname_free(element_qname, env);
416
416
                     element_qname = NULL;
417
417
                  }
418
 
 
419
 
 
420
 
 
 
418
                 
 
419
 
 
420
                     
421
421
                     /*
422
422
                      * building statusMessage element
423
423
                      */
424
 
 
425
 
 
426
 
 
 
424
                     
 
425
                     
 
426
                     
427
427
                                    /*
428
428
                                     * because elements are ordered this works fine
429
429
                                     */
430
 
 
431
 
 
 
430
                                  
 
431
                                   
432
432
                                   if(current_node != NULL && is_early_node_valid)
433
433
                                   {
434
434
                                       current_node = axiom_node_get_next_sibling(current_node, env);
435
 
 
436
 
 
 
435
                                       
 
436
                                       
437
437
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
438
438
                                        {
439
439
                                            current_node = axiom_node_get_next_sibling(current_node, env);
443
443
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
444
444
                                            qname = axiom_element_get_qname(current_element, env, current_node);
445
445
                                        }
446
 
 
 
446
                                       
447
447
                                   }
448
448
                                   is_early_node_valid = AXIS2_FALSE;
449
 
 
 
449
                                 
450
450
                                 element_qname = axutil_qname_create(env, "statusMessage", "http://eucalyptus.ucsb.edu/", NULL);
451
 
 
452
 
 
453
 
                           if (
 
451
                                 
 
452
 
 
453
                           if ( 
454
454
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
455
455
                           {
456
456
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
457
457
                              {
458
458
                                is_early_node_valid = AXIS2_TRUE;
459
459
                              }
460
 
 
461
 
 
 
460
                              
 
461
                                 
462
462
                                      text_value = axiom_element_get_text(current_element, env, current_node);
463
463
                                      if(text_value != NULL)
464
464
                                      {
465
465
                                            status = adb_stopNetworkResponseType_set_statusMessage(_stopNetworkResponseType, env,
466
466
                                                               text_value);
467
467
                                      }
468
 
 
 
468
                                      
469
469
                                 if(AXIS2_FAILURE ==  status)
470
470
                                 {
471
471
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for statusMessage ");
476
476
                                     return AXIS2_FAILURE;
477
477
                                 }
478
478
                              }
479
 
 
 
479
                           
480
480
                  if(element_qname)
481
481
                  {
482
482
                     axutil_qname_free(element_qname, env);
483
483
                     element_qname = NULL;
484
484
                  }
485
 
 
486
 
 
487
 
 
 
485
                 
 
486
 
 
487
                     
488
488
                     /*
489
489
                      * building return element
490
490
                      */
491
 
 
492
 
 
493
 
 
 
491
                     
 
492
                     
 
493
                     
494
494
                                    /*
495
495
                                     * because elements are ordered this works fine
496
496
                                     */
497
 
 
498
 
 
 
497
                                  
 
498
                                   
499
499
                                   if(current_node != NULL && is_early_node_valid)
500
500
                                   {
501
501
                                       current_node = axiom_node_get_next_sibling(current_node, env);
502
 
 
503
 
 
 
502
                                       
 
503
                                       
504
504
                                        while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
505
505
                                        {
506
506
                                            current_node = axiom_node_get_next_sibling(current_node, env);
510
510
                                            current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
511
511
                                            qname = axiom_element_get_qname(current_element, env, current_node);
512
512
                                        }
513
 
 
 
513
                                       
514
514
                                   }
515
515
                                   is_early_node_valid = AXIS2_FALSE;
516
 
 
 
516
                                 
517
517
                                 element_qname = axutil_qname_create(env, "return", "http://eucalyptus.ucsb.edu/", NULL);
518
 
 
519
 
 
520
 
                           if (
 
518
                                 
 
519
 
 
520
                           if ( 
521
521
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
522
522
                           {
523
523
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
524
524
                              {
525
525
                                is_early_node_valid = AXIS2_TRUE;
526
526
                              }
527
 
 
528
 
 
 
527
                              
 
528
                                 
529
529
                                      text_value = axiom_element_get_text(current_element, env, current_node);
530
530
                                      if(text_value != NULL)
531
531
                                      {
540
540
                                                                      AXIS2_FALSE);
541
541
                                            }
542
542
                                      }
543
 
 
 
543
                                      
544
544
                                      else
545
545
                                      {
546
546
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "NULL value is set to a non nillable element return");
547
547
                                          status = AXIS2_FAILURE;
548
548
                                      }
549
 
 
 
549
                                      
550
550
                                 if(AXIS2_FAILURE ==  status)
551
551
                                 {
552
552
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for return ");
557
557
                                     return AXIS2_FAILURE;
558
558
                                 }
559
559
                              }
560
 
 
 
560
                           
561
561
                  if(element_qname)
562
562
                  {
563
563
                     axutil_qname_free(element_qname, env);
564
564
                     element_qname = NULL;
565
565
                  }
566
 
 
 
566
                 
567
567
          return status;
568
568
       }
569
569
 
570
570
          axis2_bool_t AXIS2_CALL
571
571
          adb_stopNetworkResponseType_is_particle()
572
572
          {
573
 
 
 
573
            
574
574
                 return AXIS2_FALSE;
575
 
 
 
575
              
576
576
          }
577
577
 
578
578
 
582
582
                    const axutil_env_t *env, axiom_element_t *parent_element,
583
583
                    axutil_hash_t *namespaces, int *next_ns_index)
584
584
          {
585
 
 
 
585
            
586
586
                  /* Here this is an empty function, Nothing to declare */
587
 
 
 
587
                 
588
588
          }
589
589
 
590
 
 
591
 
 
 
590
        
 
591
        
592
592
        axiom_node_t* AXIS2_CALL
593
593
        adb_stopNetworkResponseType_serialize(
594
594
                adb_stopNetworkResponseType_t* _stopNetworkResponseType,
595
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
596
        {
597
 
 
598
 
 
 
597
            
 
598
            
599
599
             axis2_char_t *string_to_stream;
600
 
 
601
 
 
 
600
            
 
601
         
602
602
         axiom_node_t *current_node = NULL;
603
603
         int tag_closed = 0;
604
604
 
605
 
 
606
 
 
 
605
         
 
606
         
607
607
                axiom_namespace_t *ns1 = NULL;
608
608
 
609
609
                axis2_char_t *qname_uri = NULL;
610
610
                axis2_char_t *qname_prefix = NULL;
611
611
                axis2_char_t *p_prefix = NULL;
612
612
                axis2_bool_t ns_already_defined;
613
 
 
 
613
            
614
614
                    axis2_char_t *text_value_1;
615
615
                    axis2_char_t *text_value_1_temp;
616
 
 
 
616
                    
617
617
                    axis2_char_t *text_value_2;
618
618
                    axis2_char_t *text_value_2_temp;
619
 
 
 
619
                    
620
620
                    axis2_char_t *text_value_3;
621
621
                    axis2_char_t *text_value_3_temp;
622
 
 
 
622
                    
623
623
                    axis2_char_t text_value_4[64];
624
 
 
 
624
                    
625
625
               axis2_char_t *start_input_str = NULL;
626
626
               axis2_char_t *end_input_str = NULL;
627
627
               unsigned int start_input_str_len = 0;
628
628
               unsigned int end_input_str_len = 0;
629
 
 
630
 
 
 
629
            
 
630
            
631
631
               axiom_data_source_t *data_source = NULL;
632
632
               axutil_stream_t *stream = NULL;
633
633
 
634
 
 
 
634
            
635
635
 
636
636
            AXIS2_ENV_CHECK(env, NULL);
637
637
            AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, NULL);
638
 
 
639
 
 
 
638
            
 
639
            
640
640
                    current_node = parent;
641
641
                    data_source = (axiom_data_source_t *)axiom_node_get_data_element(current_node, env);
642
642
                    if (!data_source)
644
644
                    stream = axiom_data_source_get_stream(data_source, env); /* assume parent is of type data source */
645
645
                    if (!stream)
646
646
                        return NULL;
647
 
 
 
647
                  
648
648
            if(!parent_tag_closed)
649
649
            {
650
 
 
651
 
              string_to_stream = ">";
 
650
            
 
651
              string_to_stream = ">"; 
652
652
              axutil_stream_write(stream, env, string_to_stream, axutil_strlen(string_to_stream));
653
653
              tag_closed = 1;
654
 
 
 
654
            
655
655
            }
656
 
 
 
656
            
657
657
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
658
658
                       {
659
659
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
660
660
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
661
661
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
662
 
 
 
662
                           
663
663
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
664
664
                                            "http://eucalyptus.ucsb.edu/",
665
665
                                            p_prefix));
666
666
                       }
667
 
 
 
667
                      
668
668
 
669
669
                   if (!_stopNetworkResponseType->is_valid_correlationId)
670
670
                   {
671
 
 
 
671
                      
672
672
                           /* no need to complain for minoccurs=0 element */
673
 
 
674
 
 
 
673
                            
 
674
                          
675
675
                   }
676
676
                   else
677
677
                   {
678
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
 
 
 
679
                                 (4 + axutil_strlen(p_prefix) + 
 
680
                                  axutil_strlen("correlationId"))); 
 
681
                                 
682
682
                                 /* axutil_strlen("<:>") + 1 = 4 */
683
683
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
684
684
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("correlationId")));
685
685
                                  /* axutil_strlen("</:>") + 1 = 5 */
686
 
 
687
 
 
688
 
 
689
 
 
690
 
 
691
 
 
 
686
                                  
 
687
                     
 
688
 
 
689
                   
 
690
                   
 
691
                     
692
692
                     /*
693
693
                      * parsing correlationId element
694
694
                      */
695
695
 
696
 
 
697
 
 
 
696
                    
 
697
                    
698
698
                            sprintf(start_input_str, "<%s%scorrelationId>",
699
699
                                 p_prefix?p_prefix:"",
700
700
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
701
 
 
 
701
                            
702
702
                        start_input_str_len = axutil_strlen(start_input_str);
703
703
                        sprintf(end_input_str, "</%s%scorrelationId>",
704
704
                                 p_prefix?p_prefix:"",
705
705
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
706
706
                        end_input_str_len = axutil_strlen(end_input_str);
707
 
 
 
707
                    
708
708
                           text_value_1 = _stopNetworkResponseType->property_correlationId;
709
 
 
 
709
                           
710
710
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
711
 
 
712
 
 
 
711
                           
 
712
                            
713
713
                           text_value_1_temp = axutil_xml_quote_string(env, text_value_1, AXIS2_TRUE);
714
714
                           if (text_value_1_temp)
715
715
                           {
720
720
                           {
721
721
                               axutil_stream_write(stream, env, text_value_1, axutil_strlen(text_value_1));
722
722
                           }
723
 
 
 
723
                           
724
724
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
725
 
 
726
 
 
 
725
                           
 
726
                     
727
727
                     AXIS2_FREE(env->allocator,start_input_str);
728
728
                     AXIS2_FREE(env->allocator,end_input_str);
729
 
                 }
730
 
 
731
 
 
 
729
                 } 
 
730
 
 
731
                 
732
732
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
733
733
                       {
734
734
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
735
735
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
736
736
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
737
 
 
 
737
                           
738
738
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
739
739
                                            "http://eucalyptus.ucsb.edu/",
740
740
                                            p_prefix));
741
741
                       }
742
 
 
 
742
                      
743
743
 
744
744
                   if (!_stopNetworkResponseType->is_valid_userId)
745
745
                   {
746
 
 
 
746
                      
747
747
                           /* no need to complain for minoccurs=0 element */
748
 
 
749
 
 
 
748
                            
 
749
                          
750
750
                   }
751
751
                   else
752
752
                   {
753
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
 
 
 
754
                                 (4 + axutil_strlen(p_prefix) + 
 
755
                                  axutil_strlen("userId"))); 
 
756
                                 
757
757
                                 /* axutil_strlen("<:>") + 1 = 4 */
758
758
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
759
759
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("userId")));
760
760
                                  /* axutil_strlen("</:>") + 1 = 5 */
761
 
 
762
 
 
763
 
 
764
 
 
765
 
 
766
 
 
 
761
                                  
 
762
                     
 
763
 
 
764
                   
 
765
                   
 
766
                     
767
767
                     /*
768
768
                      * parsing userId element
769
769
                      */
770
770
 
771
 
 
772
 
 
 
771
                    
 
772
                    
773
773
                            sprintf(start_input_str, "<%s%suserId>",
774
774
                                 p_prefix?p_prefix:"",
775
775
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
776
 
 
 
776
                            
777
777
                        start_input_str_len = axutil_strlen(start_input_str);
778
778
                        sprintf(end_input_str, "</%s%suserId>",
779
779
                                 p_prefix?p_prefix:"",
780
780
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
781
781
                        end_input_str_len = axutil_strlen(end_input_str);
782
 
 
 
782
                    
783
783
                           text_value_2 = _stopNetworkResponseType->property_userId;
784
 
 
 
784
                           
785
785
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
786
 
 
787
 
 
 
786
                           
 
787
                            
788
788
                           text_value_2_temp = axutil_xml_quote_string(env, text_value_2, AXIS2_TRUE);
789
789
                           if (text_value_2_temp)
790
790
                           {
795
795
                           {
796
796
                               axutil_stream_write(stream, env, text_value_2, axutil_strlen(text_value_2));
797
797
                           }
798
 
 
 
798
                           
799
799
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
800
 
 
801
 
 
 
800
                           
 
801
                     
802
802
                     AXIS2_FREE(env->allocator,start_input_str);
803
803
                     AXIS2_FREE(env->allocator,end_input_str);
804
 
                 }
805
 
 
806
 
 
 
804
                 } 
 
805
 
 
806
                 
807
807
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
808
808
                       {
809
809
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
810
810
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
811
811
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
812
 
 
 
812
                           
813
813
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
814
814
                                            "http://eucalyptus.ucsb.edu/",
815
815
                                            p_prefix));
816
816
                       }
817
 
 
 
817
                      
818
818
 
819
819
                   if (!_stopNetworkResponseType->is_valid_statusMessage)
820
820
                   {
821
 
 
 
821
                      
822
822
                           /* no need to complain for minoccurs=0 element */
823
 
 
824
 
 
 
823
                            
 
824
                          
825
825
                   }
826
826
                   else
827
827
                   {
828
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
 
 
 
829
                                 (4 + axutil_strlen(p_prefix) + 
 
830
                                  axutil_strlen("statusMessage"))); 
 
831
                                 
832
832
                                 /* axutil_strlen("<:>") + 1 = 4 */
833
833
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
834
834
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("statusMessage")));
835
835
                                  /* axutil_strlen("</:>") + 1 = 5 */
836
 
 
837
 
 
838
 
 
839
 
 
840
 
 
841
 
 
 
836
                                  
 
837
                     
 
838
 
 
839
                   
 
840
                   
 
841
                     
842
842
                     /*
843
843
                      * parsing statusMessage element
844
844
                      */
845
845
 
846
 
 
847
 
 
 
846
                    
 
847
                    
848
848
                            sprintf(start_input_str, "<%s%sstatusMessage>",
849
849
                                 p_prefix?p_prefix:"",
850
850
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
851
 
 
 
851
                            
852
852
                        start_input_str_len = axutil_strlen(start_input_str);
853
853
                        sprintf(end_input_str, "</%s%sstatusMessage>",
854
854
                                 p_prefix?p_prefix:"",
855
855
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
856
856
                        end_input_str_len = axutil_strlen(end_input_str);
857
 
 
 
857
                    
858
858
                           text_value_3 = _stopNetworkResponseType->property_statusMessage;
859
 
 
 
859
                           
860
860
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
861
 
 
862
 
 
 
861
                           
 
862
                            
863
863
                           text_value_3_temp = axutil_xml_quote_string(env, text_value_3, AXIS2_TRUE);
864
864
                           if (text_value_3_temp)
865
865
                           {
870
870
                           {
871
871
                               axutil_stream_write(stream, env, text_value_3, axutil_strlen(text_value_3));
872
872
                           }
873
 
 
 
873
                           
874
874
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
875
 
 
876
 
 
 
875
                           
 
876
                     
877
877
                     AXIS2_FREE(env->allocator,start_input_str);
878
878
                     AXIS2_FREE(env->allocator,end_input_str);
879
 
                 }
880
 
 
881
 
 
 
879
                 } 
 
880
 
 
881
                 
882
882
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
883
883
                       {
884
884
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
885
885
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
886
886
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
887
 
 
 
887
                           
888
888
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
889
889
                                            "http://eucalyptus.ucsb.edu/",
890
890
                                            p_prefix));
891
891
                       }
892
 
 
 
892
                      
893
893
 
894
894
                   if (!_stopNetworkResponseType->is_valid_return)
895
895
                   {
896
 
 
 
896
                      
897
897
                           /* no need to complain for minoccurs=0 element */
898
 
 
899
 
 
 
898
                            
 
899
                          
900
900
                   }
901
901
                   else
902
902
                   {
903
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
 
 
 
904
                                 (4 + axutil_strlen(p_prefix) + 
 
905
                                  axutil_strlen("return"))); 
 
906
                                 
907
907
                                 /* axutil_strlen("<:>") + 1 = 4 */
908
908
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
909
909
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("return")));
910
910
                                  /* axutil_strlen("</:>") + 1 = 5 */
911
 
 
912
 
 
913
 
 
914
 
 
915
 
 
916
 
 
 
911
                                  
 
912
                     
 
913
 
 
914
                   
 
915
                   
 
916
                     
917
917
                     /*
918
918
                      * parsing return element
919
919
                      */
920
920
 
921
 
 
922
 
 
 
921
                    
 
922
                    
923
923
                            sprintf(start_input_str, "<%s%sreturn>",
924
924
                                 p_prefix?p_prefix:"",
925
925
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
926
 
 
 
926
                            
927
927
                        start_input_str_len = axutil_strlen(start_input_str);
928
928
                        sprintf(end_input_str, "</%s%sreturn>",
929
929
                                 p_prefix?p_prefix:"",
930
930
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
931
931
                        end_input_str_len = axutil_strlen(end_input_str);
932
 
 
 
932
                    
933
933
                           strcpy(text_value_4, (_stopNetworkResponseType->property_return)?"true":"false");
934
 
 
 
934
                           
935
935
                           axutil_stream_write(stream, env, start_input_str, start_input_str_len);
936
 
 
 
936
                           
937
937
                           axutil_stream_write(stream, env, text_value_4, axutil_strlen(text_value_4));
938
 
 
 
938
                           
939
939
                           axutil_stream_write(stream, env, end_input_str, end_input_str_len);
940
 
 
941
 
 
 
940
                           
 
941
                     
942
942
                     AXIS2_FREE(env->allocator,start_input_str);
943
943
                     AXIS2_FREE(env->allocator,end_input_str);
944
 
                 }
945
 
 
946
 
 
 
944
                 } 
 
945
 
 
946
                 
947
947
 
948
948
            return parent;
949
949
        }
950
950
 
951
951
 
952
 
 
 
952
        
953
953
 
954
954
            /**
955
955
             * getter for correlationId.
959
959
                    adb_stopNetworkResponseType_t* _stopNetworkResponseType,
960
960
                    const axutil_env_t *env)
961
961
             {
962
 
 
 
962
                
963
963
                    AXIS2_ENV_CHECK(env, NULL);
964
964
                    AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, NULL);
965
 
 
 
965
                  
966
966
 
967
967
                return _stopNetworkResponseType->property_correlationId;
968
968
             }
976
976
                    const axutil_env_t *env,
977
977
                    const axis2_char_t*  arg_correlationId)
978
978
             {
979
 
 
 
979
                
980
980
 
981
981
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
982
982
                AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
983
 
 
 
983
                
984
984
                if(_stopNetworkResponseType->is_valid_correlationId &&
985
985
                        arg_correlationId == _stopNetworkResponseType->property_correlationId)
986
986
                {
987
 
 
988
 
                    return AXIS2_SUCCESS;
 
987
                    
 
988
                    return AXIS2_SUCCESS; 
989
989
                }
990
990
 
991
991
                adb_stopNetworkResponseType_reset_correlationId(_stopNetworkResponseType, env);
992
992
 
993
 
 
 
993
                
994
994
                if(NULL == arg_correlationId)
995
995
                {
996
996
                    /* We are already done */
1003
1003
                            return AXIS2_FAILURE;
1004
1004
                        }
1005
1005
                        _stopNetworkResponseType->is_valid_correlationId = AXIS2_TRUE;
1006
 
 
 
1006
                    
1007
1007
                return AXIS2_SUCCESS;
1008
1008
             }
1009
1009
 
1010
 
 
 
1010
             
1011
1011
 
1012
1012
           /**
1013
1013
            * resetter for correlationId
1023
1023
 
1024
1024
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1025
1025
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
1026
 
 
1027
 
 
1028
 
 
1029
 
 
1030
 
 
 
1026
               
 
1027
 
 
1028
               
 
1029
            
 
1030
                
1031
1031
                if(_stopNetworkResponseType->property_correlationId != NULL)
1032
1032
                {
1033
 
 
1034
 
 
 
1033
                   
 
1034
                   
1035
1035
                        AXIS2_FREE(env-> allocator, _stopNetworkResponseType->property_correlationId);
1036
1036
                     _stopNetworkResponseType->property_correlationId = NULL;
1037
1037
                }
1038
 
 
1039
 
 
1040
 
 
1041
 
                _stopNetworkResponseType->is_valid_correlationId = AXIS2_FALSE;
 
1038
            
 
1039
                
 
1040
                
 
1041
                _stopNetworkResponseType->is_valid_correlationId = AXIS2_FALSE; 
1042
1042
               return AXIS2_SUCCESS;
1043
1043
           }
1044
1044
 
1052
1052
           {
1053
1053
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1054
1054
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_TRUE);
1055
 
 
 
1055
               
1056
1056
               return !_stopNetworkResponseType->is_valid_correlationId;
1057
1057
           }
1058
1058
 
1067
1067
               return adb_stopNetworkResponseType_reset_correlationId(_stopNetworkResponseType, env);
1068
1068
           }
1069
1069
 
1070
 
 
 
1070
           
1071
1071
 
1072
1072
            /**
1073
1073
             * getter for userId.
1077
1077
                    adb_stopNetworkResponseType_t* _stopNetworkResponseType,
1078
1078
                    const axutil_env_t *env)
1079
1079
             {
1080
 
 
 
1080
                
1081
1081
                    AXIS2_ENV_CHECK(env, NULL);
1082
1082
                    AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, NULL);
1083
 
 
 
1083
                  
1084
1084
 
1085
1085
                return _stopNetworkResponseType->property_userId;
1086
1086
             }
1094
1094
                    const axutil_env_t *env,
1095
1095
                    const axis2_char_t*  arg_userId)
1096
1096
             {
1097
 
 
 
1097
                
1098
1098
 
1099
1099
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1100
1100
                AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
1101
 
 
 
1101
                
1102
1102
                if(_stopNetworkResponseType->is_valid_userId &&
1103
1103
                        arg_userId == _stopNetworkResponseType->property_userId)
1104
1104
                {
1105
 
 
1106
 
                    return AXIS2_SUCCESS;
 
1105
                    
 
1106
                    return AXIS2_SUCCESS; 
1107
1107
                }
1108
1108
 
1109
1109
                adb_stopNetworkResponseType_reset_userId(_stopNetworkResponseType, env);
1110
1110
 
1111
 
 
 
1111
                
1112
1112
                if(NULL == arg_userId)
1113
1113
                {
1114
1114
                    /* We are already done */
1121
1121
                            return AXIS2_FAILURE;
1122
1122
                        }
1123
1123
                        _stopNetworkResponseType->is_valid_userId = AXIS2_TRUE;
1124
 
 
 
1124
                    
1125
1125
                return AXIS2_SUCCESS;
1126
1126
             }
1127
1127
 
1128
 
 
 
1128
             
1129
1129
 
1130
1130
           /**
1131
1131
            * resetter for userId
1141
1141
 
1142
1142
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1143
1143
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
1144
 
 
1145
 
 
1146
 
 
1147
 
 
1148
 
 
 
1144
               
 
1145
 
 
1146
               
 
1147
            
 
1148
                
1149
1149
                if(_stopNetworkResponseType->property_userId != NULL)
1150
1150
                {
1151
 
 
1152
 
 
 
1151
                   
 
1152
                   
1153
1153
                        AXIS2_FREE(env-> allocator, _stopNetworkResponseType->property_userId);
1154
1154
                     _stopNetworkResponseType->property_userId = NULL;
1155
1155
                }
1156
 
 
1157
 
 
1158
 
 
1159
 
                _stopNetworkResponseType->is_valid_userId = AXIS2_FALSE;
 
1156
            
 
1157
                
 
1158
                
 
1159
                _stopNetworkResponseType->is_valid_userId = AXIS2_FALSE; 
1160
1160
               return AXIS2_SUCCESS;
1161
1161
           }
1162
1162
 
1170
1170
           {
1171
1171
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1172
1172
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_TRUE);
1173
 
 
 
1173
               
1174
1174
               return !_stopNetworkResponseType->is_valid_userId;
1175
1175
           }
1176
1176
 
1185
1185
               return adb_stopNetworkResponseType_reset_userId(_stopNetworkResponseType, env);
1186
1186
           }
1187
1187
 
1188
 
 
 
1188
           
1189
1189
 
1190
1190
            /**
1191
1191
             * getter for statusMessage.
1195
1195
                    adb_stopNetworkResponseType_t* _stopNetworkResponseType,
1196
1196
                    const axutil_env_t *env)
1197
1197
             {
1198
 
 
 
1198
                
1199
1199
                    AXIS2_ENV_CHECK(env, NULL);
1200
1200
                    AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, NULL);
1201
 
 
 
1201
                  
1202
1202
 
1203
1203
                return _stopNetworkResponseType->property_statusMessage;
1204
1204
             }
1212
1212
                    const axutil_env_t *env,
1213
1213
                    const axis2_char_t*  arg_statusMessage)
1214
1214
             {
1215
 
 
 
1215
                
1216
1216
 
1217
1217
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1218
1218
                AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
1219
 
 
 
1219
                
1220
1220
                if(_stopNetworkResponseType->is_valid_statusMessage &&
1221
1221
                        arg_statusMessage == _stopNetworkResponseType->property_statusMessage)
1222
1222
                {
1223
 
 
1224
 
                    return AXIS2_SUCCESS;
 
1223
                    
 
1224
                    return AXIS2_SUCCESS; 
1225
1225
                }
1226
1226
 
1227
1227
                adb_stopNetworkResponseType_reset_statusMessage(_stopNetworkResponseType, env);
1228
1228
 
1229
 
 
 
1229
                
1230
1230
                if(NULL == arg_statusMessage)
1231
1231
                {
1232
1232
                    /* We are already done */
1239
1239
                            return AXIS2_FAILURE;
1240
1240
                        }
1241
1241
                        _stopNetworkResponseType->is_valid_statusMessage = AXIS2_TRUE;
1242
 
 
 
1242
                    
1243
1243
                return AXIS2_SUCCESS;
1244
1244
             }
1245
1245
 
1246
 
 
 
1246
             
1247
1247
 
1248
1248
           /**
1249
1249
            * resetter for statusMessage
1259
1259
 
1260
1260
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1261
1261
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
1262
 
 
1263
 
 
1264
 
 
1265
 
 
1266
 
 
 
1262
               
 
1263
 
 
1264
               
 
1265
            
 
1266
                
1267
1267
                if(_stopNetworkResponseType->property_statusMessage != NULL)
1268
1268
                {
1269
 
 
1270
 
 
 
1269
                   
 
1270
                   
1271
1271
                        AXIS2_FREE(env-> allocator, _stopNetworkResponseType->property_statusMessage);
1272
1272
                     _stopNetworkResponseType->property_statusMessage = NULL;
1273
1273
                }
1274
 
 
1275
 
 
1276
 
 
1277
 
                _stopNetworkResponseType->is_valid_statusMessage = AXIS2_FALSE;
 
1274
            
 
1275
                
 
1276
                
 
1277
                _stopNetworkResponseType->is_valid_statusMessage = AXIS2_FALSE; 
1278
1278
               return AXIS2_SUCCESS;
1279
1279
           }
1280
1280
 
1288
1288
           {
1289
1289
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1290
1290
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_TRUE);
1291
 
 
 
1291
               
1292
1292
               return !_stopNetworkResponseType->is_valid_statusMessage;
1293
1293
           }
1294
1294
 
1303
1303
               return adb_stopNetworkResponseType_reset_statusMessage(_stopNetworkResponseType, env);
1304
1304
           }
1305
1305
 
1306
 
 
 
1306
           
1307
1307
 
1308
1308
            /**
1309
1309
             * getter for return.
1313
1313
                    adb_stopNetworkResponseType_t* _stopNetworkResponseType,
1314
1314
                    const axutil_env_t *env)
1315
1315
             {
1316
 
 
 
1316
                
1317
1317
                    AXIS2_ENV_CHECK(env, (axis2_bool_t)0);
1318
1318
                    AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, (axis2_bool_t)0);
1319
 
 
 
1319
                  
1320
1320
 
1321
1321
                return _stopNetworkResponseType->property_return;
1322
1322
             }
1330
1330
                    const axutil_env_t *env,
1331
1331
                    axis2_bool_t  arg_return)
1332
1332
             {
1333
 
 
 
1333
                
1334
1334
 
1335
1335
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1336
1336
                AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
1337
 
 
 
1337
                
1338
1338
                if(_stopNetworkResponseType->is_valid_return &&
1339
1339
                        arg_return == _stopNetworkResponseType->property_return)
1340
1340
                {
1341
 
 
1342
 
                    return AXIS2_SUCCESS;
 
1341
                    
 
1342
                    return AXIS2_SUCCESS; 
1343
1343
                }
1344
1344
 
1345
1345
                adb_stopNetworkResponseType_reset_return(_stopNetworkResponseType, env);
1346
1346
 
1347
1347
                _stopNetworkResponseType->property_return = arg_return;
1348
1348
                        _stopNetworkResponseType->is_valid_return = AXIS2_TRUE;
1349
 
 
 
1349
                    
1350
1350
                return AXIS2_SUCCESS;
1351
1351
             }
1352
1352
 
1353
 
 
 
1353
             
1354
1354
 
1355
1355
           /**
1356
1356
            * resetter for return
1366
1366
 
1367
1367
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
1368
1368
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_FAILURE);
1369
 
 
1370
 
 
1371
 
               _stopNetworkResponseType->is_valid_return = AXIS2_FALSE;
 
1369
               
 
1370
 
 
1371
               _stopNetworkResponseType->is_valid_return = AXIS2_FALSE; 
1372
1372
               return AXIS2_SUCCESS;
1373
1373
           }
1374
1374
 
1382
1382
           {
1383
1383
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
1384
1384
               AXIS2_PARAM_CHECK(env->error, _stopNetworkResponseType, AXIS2_TRUE);
1385
 
 
 
1385
               
1386
1386
               return !_stopNetworkResponseType->is_valid_return;
1387
1387
           }
1388
1388
 
1397
1397
               return adb_stopNetworkResponseType_reset_return(_stopNetworkResponseType, env);
1398
1398
           }
1399
1399
 
1400
 
 
 
1400
           
1401
1401