← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gatherlog/generated/adb_GetKeysResponse.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:
gatherlog/generated/adb_GetKeysResponse.c
 
1
 
 
2
 
 
3
        /**
 
4
         * adb_GetKeysResponse.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_GetKeysResponse.h"
 
11
        
 
12
               /*
 
13
                * implmentation of the GetKeysResponse|http://eucalyptus.ucsb.edu/ element
 
14
                */
 
15
           
 
16
 
 
17
 
 
18
        struct adb_GetKeysResponse
 
19
        {
 
20
            
 
21
                axutil_qname_t* qname;
 
22
            adb_getKeysResponseType_t* property_GetKeysResponse;
 
23
 
 
24
                
 
25
                axis2_bool_t is_valid_GetKeysResponse;
 
26
 
 
27
 
 
28
            
 
29
        };
 
30
 
 
31
 
 
32
       /************************* Private Function prototypes ********************************/
 
33
        
 
34
 
 
35
 
 
36
       /************************* Function Implmentations ********************************/
 
37
        adb_GetKeysResponse_t* AXIS2_CALL
 
38
        adb_GetKeysResponse_create(
 
39
            const axutil_env_t *env)
 
40
        {
 
41
            adb_GetKeysResponse_t *_GetKeysResponse = NULL;
 
42
            
 
43
                axutil_qname_t* qname = NULL;
 
44
            
 
45
            AXIS2_ENV_CHECK(env, NULL);
 
46
 
 
47
            _GetKeysResponse = (adb_GetKeysResponse_t *) AXIS2_MALLOC(env->
 
48
                allocator, sizeof(adb_GetKeysResponse_t));
 
49
 
 
50
            if(NULL == _GetKeysResponse)
 
51
            {
 
52
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
 
53
                return NULL;
 
54
            }
 
55
 
 
56
            memset(_GetKeysResponse, 0, sizeof(adb_GetKeysResponse_t));
 
57
 
 
58
            _GetKeysResponse->property_GetKeysResponse  = NULL;
 
59
                  _GetKeysResponse->is_valid_GetKeysResponse  = AXIS2_FALSE;
 
60
            
 
61
                  qname =  axutil_qname_create (env,
 
62
                        "GetKeysResponse",
 
63
                        "http://eucalyptus.ucsb.edu/",
 
64
                        NULL);
 
65
                _GetKeysResponse->qname = qname;
 
66
            
 
67
 
 
68
            return _GetKeysResponse;
 
69
        }
 
70
 
 
71
        axis2_status_t AXIS2_CALL
 
72
        adb_GetKeysResponse_free (
 
73
                adb_GetKeysResponse_t* _GetKeysResponse,
 
74
                const axutil_env_t *env)
 
75
        {
 
76
            
 
77
 
 
78
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
79
            AXIS2_PARAM_CHECK(env->error, _GetKeysResponse, AXIS2_FAILURE);
 
80
 
 
81
            adb_GetKeysResponse_reset_GetKeysResponse(_GetKeysResponse, env);
 
82
            
 
83
              if(_GetKeysResponse->qname)
 
84
              {
 
85
                  axutil_qname_free (_GetKeysResponse->qname, env);
 
86
                  _GetKeysResponse->qname = NULL;
 
87
              }
 
88
            
 
89
 
 
90
            if(_GetKeysResponse)
 
91
            {
 
92
                AXIS2_FREE(env->allocator, _GetKeysResponse);
 
93
                _GetKeysResponse = NULL;
 
94
            }
 
95
            return AXIS2_SUCCESS;
 
96
        }
 
97
 
 
98
 
 
99
        
 
100
 
 
101
        axis2_status_t AXIS2_CALL
 
102
        adb_GetKeysResponse_deserialize(
 
103
                adb_GetKeysResponse_t* _GetKeysResponse,
 
104
                const axutil_env_t *env,
 
105
                axiom_node_t **dp_parent,
 
106
                axis2_bool_t *dp_is_early_node_valid,
 
107
                axis2_bool_t dont_care_minoccurs)
 
108
        {
 
109
          axiom_node_t *parent = *dp_parent;
 
110
          
 
111
          axis2_status_t status = AXIS2_SUCCESS;
 
112
          
 
113
              void *element = NULL;
 
114
           
 
115
             axis2_char_t* text_value = NULL;
 
116
             axutil_qname_t *qname = NULL;
 
117
          
 
118
            axutil_qname_t *element_qname = NULL; 
 
119
            
 
120
               axiom_node_t *first_node = NULL;
 
121
               axis2_bool_t is_early_node_valid = AXIS2_TRUE;
 
122
               axiom_node_t *current_node = NULL;
 
123
               axiom_element_t *current_element = NULL;
 
124
            
 
125
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
126
            AXIS2_PARAM_CHECK(env->error, _GetKeysResponse, AXIS2_FAILURE);
 
127
 
 
128
            
 
129
              
 
130
              while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
 
131
              {
 
132
                  parent = axiom_node_get_next_sibling(parent, env);
 
133
              }
 
134
              if (NULL == parent)
 
135
              {
 
136
                /* This should be checked before everything */
 
137
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
 
138
                            "Failed in building adb object for GetKeysResponse : "
 
139
                            "NULL elemenet can not be passed to deserialize");
 
140
                return AXIS2_FAILURE;
 
141
              }
 
142
              
 
143
 
 
144
                    current_element = (axiom_element_t *)axiom_node_get_data_element(parent, env);
 
145
                    qname = axiom_element_get_qname(current_element, env, parent);
 
146
                    if (axutil_qname_equals(qname, env, _GetKeysResponse-> qname))
 
147
                    {
 
148
                        
 
149
                          first_node = parent;
 
150
                          
 
151
                    }
 
152
                    else
 
153
                    {
 
154
                        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, 
 
155
                              "Failed in building adb object for GetKeysResponse : "
 
156
                              "Expected %s but returned %s",
 
157
                              axutil_qname_to_string(_GetKeysResponse-> qname, env),
 
158
                              axutil_qname_to_string(qname, env));
 
159
                        
 
160
                        return AXIS2_FAILURE;
 
161
                    }
 
162
                    
 
163
 
 
164
                     
 
165
                     /*
 
166
                      * building GetKeysResponse element
 
167
                      */
 
168
                     
 
169
                     
 
170
                     
 
171
                                   current_node = first_node;
 
172
                                   is_early_node_valid = AXIS2_FALSE;
 
173
                                   
 
174
                                   
 
175
                                    while(current_node && axiom_node_get_node_type(current_node, env) != AXIOM_ELEMENT)
 
176
                                    {
 
177
                                        current_node = axiom_node_get_next_sibling(current_node, env);
 
178
                                    }
 
179
                                    if(current_node != NULL)
 
180
                                    {
 
181
                                        current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, env);
 
182
                                        qname = axiom_element_get_qname(current_element, env, current_node);
 
183
                                    }
 
184
                                   
 
185
                                 element_qname = axutil_qname_create(env, "GetKeysResponse", "http://eucalyptus.ucsb.edu/", NULL);
 
186
                                 
 
187
 
 
188
                           if (adb_getKeysResponseType_is_particle() ||  
 
189
                                (current_node   && current_element && (axutil_qname_equals(element_qname, env, qname))))
 
190
                           {
 
191
                              if( current_node   && current_element && (axutil_qname_equals(element_qname, env, qname)))
 
192
                              {
 
193
                                is_early_node_valid = AXIS2_TRUE;
 
194
                              }
 
195
                              
 
196
                                 
 
197
                                      element = (void*)adb_getKeysResponseType_create(env);
 
198
 
 
199
                                      status =  adb_getKeysResponseType_deserialize((adb_getKeysResponseType_t*)element,
 
200
                                                                            env, &current_node, &is_early_node_valid, AXIS2_FALSE);
 
201
                                      if(AXIS2_FAILURE == status)
 
202
                                      {
 
203
                                          AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in building adb object for element GetKeysResponse");
 
204
                                      }
 
205
                                      else
 
206
                                      {
 
207
                                          status = adb_GetKeysResponse_set_GetKeysResponse(_GetKeysResponse, env,
 
208
                                                                   (adb_getKeysResponseType_t*)element);
 
209
                                      }
 
210
                                    
 
211
                                 if(AXIS2_FAILURE ==  status)
 
212
                                 {
 
213
                                     AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "failed in setting the value for GetKeysResponse ");
 
214
                                     if(element_qname)
 
215
                                     {
 
216
                                         axutil_qname_free(element_qname, env);
 
217
                                     }
 
218
                                     return AXIS2_FAILURE;
 
219
                                 }
 
220
                              }
 
221
                           
 
222
                              else if(!dont_care_minoccurs)
 
223
                              {
 
224
                                  if(element_qname)
 
225
                                  {
 
226
                                      axutil_qname_free(element_qname, env);
 
227
                                  }
 
228
                                  /* this is not a nillable element*/
 
229
                                  AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "non nillable or minOuccrs != 0 element GetKeysResponse missing");
 
230
                                  return AXIS2_FAILURE;
 
231
                              }
 
232
                           
 
233
                  if(element_qname)
 
234
                  {
 
235
                     axutil_qname_free(element_qname, env);
 
236
                     element_qname = NULL;
 
237
                  }
 
238
                 
 
239
          return status;
 
240
       }
 
241
 
 
242
          axis2_bool_t AXIS2_CALL
 
243
          adb_GetKeysResponse_is_particle()
 
244
          {
 
245
            
 
246
                 return AXIS2_FALSE;
 
247
              
 
248
          }
 
249
 
 
250
 
 
251
          void AXIS2_CALL
 
252
          adb_GetKeysResponse_declare_parent_namespaces(
 
253
                    adb_GetKeysResponse_t* _GetKeysResponse,
 
254
                    const axutil_env_t *env, axiom_element_t *parent_element,
 
255
                    axutil_hash_t *namespaces, int *next_ns_index)
 
256
          {
 
257
            
 
258
                  /* Here this is an empty function, Nothing to declare */
 
259
                 
 
260
          }
 
261
 
 
262
        
 
263
        
 
264
        axiom_node_t* AXIS2_CALL
 
265
        adb_GetKeysResponse_serialize(
 
266
                adb_GetKeysResponse_t* _GetKeysResponse,
 
267
                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)
 
268
        {
 
269
            
 
270
            
 
271
         
 
272
         axiom_node_t *current_node = NULL;
 
273
         int tag_closed = 0;
 
274
 
 
275
         
 
276
         
 
277
                axiom_namespace_t *ns1 = NULL;
 
278
 
 
279
                axis2_char_t *qname_uri = NULL;
 
280
                axis2_char_t *qname_prefix = NULL;
 
281
                axis2_char_t *p_prefix = NULL;
 
282
                axis2_bool_t ns_already_defined;
 
283
            
 
284
                    axis2_char_t text_value_1[64];
 
285
                    
 
286
               axis2_char_t *start_input_str = NULL;
 
287
               axis2_char_t *end_input_str = NULL;
 
288
               unsigned int start_input_str_len = 0;
 
289
               unsigned int end_input_str_len = 0;
 
290
            
 
291
            
 
292
               axiom_data_source_t *data_source = NULL;
 
293
               axutil_stream_t *stream = NULL;
 
294
 
 
295
             
 
296
                int next_ns_index_value = 0;
 
297
            
 
298
 
 
299
            AXIS2_ENV_CHECK(env, NULL);
 
300
            AXIS2_PARAM_CHECK(env->error, _GetKeysResponse, NULL);
 
301
            
 
302
             
 
303
                    namespaces = axutil_hash_make(env);
 
304
                    next_ns_index = &next_ns_index_value;
 
305
                     
 
306
                           ns1 = axiom_namespace_create (env,
 
307
                                             "http://eucalyptus.ucsb.edu/",
 
308
                                             "n"); 
 
309
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, axutil_strdup(env, "n"));
 
310
                       
 
311
                     
 
312
                    parent_element = axiom_element_create (env, NULL, "GetKeysResponse", ns1 , &parent);
 
313
                    
 
314
                    
 
315
                    axiom_element_set_namespace(parent_element, env, ns1, parent);
 
316
 
 
317
 
 
318
            
 
319
                    data_source = axiom_data_source_create(env, parent, &current_node);
 
320
                    stream = axiom_data_source_get_stream(data_source, env);
 
321
                  
 
322
                       if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING)))
 
323
                       {
 
324
                           p_prefix = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 
325
                           sprintf(p_prefix, "n%d", (*next_ns_index)++);
 
326
                           axutil_hash_set(namespaces, "http://eucalyptus.ucsb.edu/", AXIS2_HASH_KEY_STRING, p_prefix);
 
327
                           
 
328
                           axiom_element_declare_namespace_assume_param_ownership(parent_element, env, axiom_namespace_create (env,
 
329
                                            "http://eucalyptus.ucsb.edu/",
 
330
                                            p_prefix));
 
331
                       }
 
332
                      
 
333
 
 
334
                   if (!_GetKeysResponse->is_valid_GetKeysResponse)
 
335
                   {
 
336
                      
 
337
                            
 
338
                            start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
339
                                        (5 + axutil_strlen(p_prefix) + 
 
340
                                         axutil_strlen("GetKeysResponse") + 
 
341
                                         axutil_strlen(" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:nil=\"1\""))); 
 
342
                                        
 
343
                            
 
344
                            sprintf(start_input_str, "<%s%sGetKeysResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:nil=\"1\"/>",
 
345
                                        p_prefix?p_prefix:"",
 
346
                                        (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
347
                                        
 
348
                            axutil_stream_write(stream, env, start_input_str, axutil_strlen(start_input_str));
 
349
                            AXIS2_FREE(env->allocator,start_input_str);
 
350
                          
 
351
                   }
 
352
                   else
 
353
                   {
 
354
                     start_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
355
                                 (4 + axutil_strlen(p_prefix) + 
 
356
                                  axutil_strlen("GetKeysResponse"))); 
 
357
                                 
 
358
                                 /* axutil_strlen("<:>") + 1 = 4 */
 
359
                     end_input_str = (axis2_char_t*)AXIS2_MALLOC(env->allocator, sizeof(axis2_char_t) *
 
360
                                 (5 + axutil_strlen(p_prefix) + axutil_strlen("GetKeysResponse")));
 
361
                                  /* axutil_strlen("</:>") + 1 = 5 */
 
362
                                  
 
363
                     
 
364
 
 
365
                   
 
366
                   
 
367
                     
 
368
                     /*
 
369
                      * parsing GetKeysResponse element
 
370
                      */
 
371
 
 
372
                    
 
373
                    
 
374
                            sprintf(start_input_str, "<%s%sGetKeysResponse",
 
375
                                 p_prefix?p_prefix:"",
 
376
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":""); 
 
377
                            
 
378
                        start_input_str_len = axutil_strlen(start_input_str);
 
379
                        sprintf(end_input_str, "</%s%sGetKeysResponse>",
 
380
                                 p_prefix?p_prefix:"",
 
381
                                 (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 
382
                        end_input_str_len = axutil_strlen(end_input_str);
 
383
                    
 
384
                            adb_getKeysResponseType_serialize(_GetKeysResponse->property_GetKeysResponse, 
 
385
                                                                                 env, current_node, parent_element,
 
386
                                                                                 adb_getKeysResponseType_is_particle() || AXIS2_TRUE, namespaces, next_ns_index);
 
387
                            
 
388
                     
 
389
                     AXIS2_FREE(env->allocator,start_input_str);
 
390
                     AXIS2_FREE(env->allocator,end_input_str);
 
391
                 } 
 
392
 
 
393
                 
 
394
                   if(namespaces)
 
395
                   {
 
396
                       axutil_hash_index_t *hi;
 
397
                       void *val;
 
398
                       for (hi = axutil_hash_first(namespaces, env); hi; hi = axutil_hash_next(env, hi)) 
 
399
                       {
 
400
                           axutil_hash_this(hi, NULL, NULL, &val);
 
401
                           AXIS2_FREE(env->allocator, val);
 
402
                       }
 
403
                       axutil_hash_free(namespaces, env);
 
404
                   }
 
405
                
 
406
 
 
407
            return parent;
 
408
        }
 
409
 
 
410
 
 
411
        
 
412
 
 
413
            /**
 
414
             * getter for GetKeysResponse.
 
415
             */
 
416
            adb_getKeysResponseType_t* AXIS2_CALL
 
417
            adb_GetKeysResponse_get_GetKeysResponse(
 
418
                    adb_GetKeysResponse_t* _GetKeysResponse,
 
419
                    const axutil_env_t *env)
 
420
             {
 
421
                
 
422
                    AXIS2_ENV_CHECK(env, NULL);
 
423
                    AXIS2_PARAM_CHECK(env->error, _GetKeysResponse, NULL);
 
424
                  
 
425
 
 
426
                return _GetKeysResponse->property_GetKeysResponse;
 
427
             }
 
428
 
 
429
            /**
 
430
             * setter for GetKeysResponse
 
431
             */
 
432
            axis2_status_t AXIS2_CALL
 
433
            adb_GetKeysResponse_set_GetKeysResponse(
 
434
                    adb_GetKeysResponse_t* _GetKeysResponse,
 
435
                    const axutil_env_t *env,
 
436
                    adb_getKeysResponseType_t*  arg_GetKeysResponse)
 
437
             {
 
438
                
 
439
 
 
440
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
441
                AXIS2_PARAM_CHECK(env->error, _GetKeysResponse, AXIS2_FAILURE);
 
442
                
 
443
                if(_GetKeysResponse->is_valid_GetKeysResponse &&
 
444
                        arg_GetKeysResponse == _GetKeysResponse->property_GetKeysResponse)
 
445
                {
 
446
                    
 
447
                    return AXIS2_SUCCESS; 
 
448
                }
 
449
 
 
450
                adb_GetKeysResponse_reset_GetKeysResponse(_GetKeysResponse, env);
 
451
 
 
452
                
 
453
                if(NULL == arg_GetKeysResponse)
 
454
                {
 
455
                    /* We are already done */
 
456
                    return AXIS2_SUCCESS;
 
457
                }
 
458
                _GetKeysResponse->property_GetKeysResponse = arg_GetKeysResponse;
 
459
                        _GetKeysResponse->is_valid_GetKeysResponse = AXIS2_TRUE;
 
460
                    
 
461
                return AXIS2_SUCCESS;
 
462
             }
 
463
 
 
464
             
 
465
 
 
466
           /**
 
467
            * resetter for GetKeysResponse
 
468
            */
 
469
           axis2_status_t AXIS2_CALL
 
470
           adb_GetKeysResponse_reset_GetKeysResponse(
 
471
                   adb_GetKeysResponse_t* _GetKeysResponse,
 
472
                   const axutil_env_t *env)
 
473
           {
 
474
               int i = 0;
 
475
               int count = 0;
 
476
               void *element = NULL;
 
477
 
 
478
               AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
 
479
               AXIS2_PARAM_CHECK(env->error, _GetKeysResponse, AXIS2_FAILURE);
 
480
               
 
481
 
 
482
               
 
483
            
 
484
                
 
485
                if(_GetKeysResponse->property_GetKeysResponse != NULL)
 
486
                {
 
487
                   
 
488
                   
 
489
                        adb_getKeysResponseType_free(_GetKeysResponse->property_GetKeysResponse, env);
 
490
                     _GetKeysResponse->property_GetKeysResponse = NULL;
 
491
                }
 
492
            
 
493
                
 
494
                
 
495
                _GetKeysResponse->is_valid_GetKeysResponse = AXIS2_FALSE; 
 
496
               return AXIS2_SUCCESS;
 
497
           }
 
498
 
 
499
           /**
 
500
            * Check whether GetKeysResponse is nill
 
501
            */
 
502
           axis2_bool_t AXIS2_CALL
 
503
           adb_GetKeysResponse_is_GetKeysResponse_nil(
 
504
                   adb_GetKeysResponse_t* _GetKeysResponse,
 
505
                   const axutil_env_t *env)
 
506
           {
 
507
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
 
508
               AXIS2_PARAM_CHECK(env->error, _GetKeysResponse, AXIS2_TRUE);
 
509
               
 
510
               return !_GetKeysResponse->is_valid_GetKeysResponse;
 
511
           }
 
512
 
 
513
           /**
 
514
            * Set GetKeysResponse to nill (currently the same as reset)
 
515
            */
 
516
           axis2_status_t AXIS2_CALL
 
517
           adb_GetKeysResponse_set_GetKeysResponse_nil(
 
518
                   adb_GetKeysResponse_t* _GetKeysResponse,
 
519
                   const axutil_env_t *env)
 
520
           {
 
521
               return adb_GetKeysResponse_reset_GetKeysResponse(_GetKeysResponse, env);
 
522
           }
 
523
 
 
524
           
 
525