← Back to branch summary

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

« back to all changes in this revision

Viewing changes to node/generated/adb_ncStartNetworkResponse.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:
node/generated/adb_ncStartNetworkResponse.c
1
 
 
2
 
 
3
 
        /**
4
 
         * adb_ncStartNetworkResponse.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_ncStartNetworkResponse.h"
11
 
 
12
 
               /*
13
 
                * implmentation of the ncStartNetworkResponse|http://eucalyptus.ucsb.edu/ element
14
 
                */
15
 
 
16
 
 
17
 
 
18
 
        struct adb_ncStartNetworkResponse
19
 
        {
20
 
 
21
 
                axutil_qname_t* qname;
22
 
            adb_ncStartNetworkResponseType_t* property_ncStartNetworkResponse;
23
 
 
24
 
 
25
 
                axis2_bool_t is_valid_ncStartNetworkResponse;
26
 
 
27
 
 
28
 
 
29
 
        };
30
 
 
31
 
 
32
 
       /************************* Private Function prototypes ********************************/
33
 
 
34
 
 
35
 
 
36
 
       /************************* Function Implmentations ********************************/
37
 
        adb_ncStartNetworkResponse_t* AXIS2_CALL
38
 
        adb_ncStartNetworkResponse_create(
39
 
            const axutil_env_t *env)
40
 
        {
41
 
            adb_ncStartNetworkResponse_t *_ncStartNetworkResponse = NULL;
42
 
 
43
 
                axutil_qname_t* qname = NULL;
44
 
 
45
 
            AXIS2_ENV_CHECK(env, NULL);
46
 
 
47
 
            _ncStartNetworkResponse = (adb_ncStartNetworkResponse_t *) AXIS2_MALLOC(env->
48
 
                allocator, sizeof(adb_ncStartNetworkResponse_t));
49
 
 
50
 
            if(NULL == _ncStartNetworkResponse)
51
 
            {
52
 
                AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
53
 
                return NULL;
54
 
            }
55
 
 
56
 
            memset(_ncStartNetworkResponse, 0, sizeof(adb_ncStartNetworkResponse_t));
57
 
 
58
 
            _ncStartNetworkResponse->property_ncStartNetworkResponse  = NULL;
59
 
                  _ncStartNetworkResponse->is_valid_ncStartNetworkResponse  = AXIS2_FALSE;
60
 
 
61
 
                  qname =  axutil_qname_create (env,
62
 
                        "ncStartNetworkResponse",
63
 
                        "http://eucalyptus.ucsb.edu/",
64
 
                        NULL);
65
 
                _ncStartNetworkResponse->qname = qname;
66
 
 
67
 
 
68
 
            return _ncStartNetworkResponse;
69
 
        }
70
 
 
71
 
        axis2_status_t AXIS2_CALL
72
 
        adb_ncStartNetworkResponse_free (
73
 
                adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
74
 
                const axutil_env_t *env)
75
 
        {
76
 
 
77
 
 
78
 
            AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
79
 
            AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponse, AXIS2_FAILURE);
80
 
 
81
 
            adb_ncStartNetworkResponse_reset_ncStartNetworkResponse(_ncStartNetworkResponse, env);
82
 
 
83
 
              if(_ncStartNetworkResponse->qname)
84
 
              {
85
 
                  axutil_qname_free (_ncStartNetworkResponse->qname, env);
86
 
                  _ncStartNetworkResponse->qname = NULL;
87
 
              }
88
 
 
89
 
 
90
 
            if(_ncStartNetworkResponse)
91
 
            {
92
 
                AXIS2_FREE(env->allocator, _ncStartNetworkResponse);
93
 
                _ncStartNetworkResponse = NULL;
94
 
            }
95
 
            return AXIS2_SUCCESS;
96
 
        }
97
 
 
98
 
 
99
 
 
100
 
 
101
 
        axis2_status_t AXIS2_CALL
102
 
        adb_ncStartNetworkResponse_deserialize(
103
 
                adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
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, _ncStartNetworkResponse, 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 ncStartNetworkResponse : "
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, _ncStartNetworkResponse-> 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 ncStartNetworkResponse : "
156
 
                              "Expected %s but returned %s",
157
 
                              axutil_qname_to_string(_ncStartNetworkResponse-> qname, env),
158
 
                              axutil_qname_to_string(qname, env));
159
 
 
160
 
                        return AXIS2_FAILURE;
161
 
                    }
162
 
 
163
 
 
164
 
 
165
 
                     /*
166
 
                      * building ncStartNetworkResponse 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, "ncStartNetworkResponse", "http://eucalyptus.ucsb.edu/", NULL);
186
 
 
187
 
 
188
 
                           if (adb_ncStartNetworkResponseType_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_ncStartNetworkResponseType_create(env);
198
 
 
199
 
                                      status =  adb_ncStartNetworkResponseType_deserialize((adb_ncStartNetworkResponseType_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 ncStartNetworkResponse");
204
 
                                      }
205
 
                                      else
206
 
                                      {
207
 
                                          status = adb_ncStartNetworkResponse_set_ncStartNetworkResponse(_ncStartNetworkResponse, env,
208
 
                                                                   (adb_ncStartNetworkResponseType_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 ncStartNetworkResponse ");
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 ncStartNetworkResponse 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_ncStartNetworkResponse_is_particle()
244
 
          {
245
 
 
246
 
                 return AXIS2_FALSE;
247
 
 
248
 
          }
249
 
 
250
 
 
251
 
          void AXIS2_CALL
252
 
          adb_ncStartNetworkResponse_declare_parent_namespaces(
253
 
                    adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
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_ncStartNetworkResponse_serialize(
266
 
                adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
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, _ncStartNetworkResponse, 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, "ncStartNetworkResponse", 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 (!_ncStartNetworkResponse->is_valid_ncStartNetworkResponse)
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("ncStartNetworkResponse") +
341
 
                                         axutil_strlen(" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:nil=\"1\"")));
342
 
 
343
 
 
344
 
                            sprintf(start_input_str, "<%s%sncStartNetworkResponse 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("ncStartNetworkResponse")));
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("ncStartNetworkResponse")));
361
 
                                  /* axutil_strlen("</:>") + 1 = 5 */
362
 
 
363
 
 
364
 
 
365
 
 
366
 
 
367
 
 
368
 
                     /*
369
 
                      * parsing ncStartNetworkResponse element
370
 
                      */
371
 
 
372
 
 
373
 
 
374
 
                            sprintf(start_input_str, "<%s%sncStartNetworkResponse",
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%sncStartNetworkResponse>",
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_ncStartNetworkResponseType_serialize(_ncStartNetworkResponse->property_ncStartNetworkResponse,
385
 
                                                                                 env, current_node, parent_element,
386
 
                                                                                 adb_ncStartNetworkResponseType_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 ncStartNetworkResponse.
415
 
             */
416
 
            adb_ncStartNetworkResponseType_t* AXIS2_CALL
417
 
            adb_ncStartNetworkResponse_get_ncStartNetworkResponse(
418
 
                    adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
419
 
                    const axutil_env_t *env)
420
 
             {
421
 
 
422
 
                    AXIS2_ENV_CHECK(env, NULL);
423
 
                    AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponse, NULL);
424
 
 
425
 
 
426
 
                return _ncStartNetworkResponse->property_ncStartNetworkResponse;
427
 
             }
428
 
 
429
 
            /**
430
 
             * setter for ncStartNetworkResponse
431
 
             */
432
 
            axis2_status_t AXIS2_CALL
433
 
            adb_ncStartNetworkResponse_set_ncStartNetworkResponse(
434
 
                    adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
435
 
                    const axutil_env_t *env,
436
 
                    adb_ncStartNetworkResponseType_t*  arg_ncStartNetworkResponse)
437
 
             {
438
 
 
439
 
 
440
 
                AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
441
 
                AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponse, AXIS2_FAILURE);
442
 
 
443
 
                if(_ncStartNetworkResponse->is_valid_ncStartNetworkResponse &&
444
 
                        arg_ncStartNetworkResponse == _ncStartNetworkResponse->property_ncStartNetworkResponse)
445
 
                {
446
 
 
447
 
                    return AXIS2_SUCCESS;
448
 
                }
449
 
 
450
 
                adb_ncStartNetworkResponse_reset_ncStartNetworkResponse(_ncStartNetworkResponse, env);
451
 
 
452
 
 
453
 
                if(NULL == arg_ncStartNetworkResponse)
454
 
                {
455
 
                    /* We are already done */
456
 
                    return AXIS2_SUCCESS;
457
 
                }
458
 
                _ncStartNetworkResponse->property_ncStartNetworkResponse = arg_ncStartNetworkResponse;
459
 
                        _ncStartNetworkResponse->is_valid_ncStartNetworkResponse = AXIS2_TRUE;
460
 
 
461
 
                return AXIS2_SUCCESS;
462
 
             }
463
 
 
464
 
 
465
 
 
466
 
           /**
467
 
            * resetter for ncStartNetworkResponse
468
 
            */
469
 
           axis2_status_t AXIS2_CALL
470
 
           adb_ncStartNetworkResponse_reset_ncStartNetworkResponse(
471
 
                   adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
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, _ncStartNetworkResponse, AXIS2_FAILURE);
480
 
 
481
 
 
482
 
 
483
 
 
484
 
 
485
 
                if(_ncStartNetworkResponse->property_ncStartNetworkResponse != NULL)
486
 
                {
487
 
 
488
 
 
489
 
                        adb_ncStartNetworkResponseType_free(_ncStartNetworkResponse->property_ncStartNetworkResponse, env);
490
 
                     _ncStartNetworkResponse->property_ncStartNetworkResponse = NULL;
491
 
                }
492
 
 
493
 
 
494
 
 
495
 
                _ncStartNetworkResponse->is_valid_ncStartNetworkResponse = AXIS2_FALSE;
496
 
               return AXIS2_SUCCESS;
497
 
           }
498
 
 
499
 
           /**
500
 
            * Check whether ncStartNetworkResponse is nill
501
 
            */
502
 
           axis2_bool_t AXIS2_CALL
503
 
           adb_ncStartNetworkResponse_is_ncStartNetworkResponse_nil(
504
 
                   adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
505
 
                   const axutil_env_t *env)
506
 
           {
507
 
               AXIS2_ENV_CHECK(env, AXIS2_TRUE);
508
 
               AXIS2_PARAM_CHECK(env->error, _ncStartNetworkResponse, AXIS2_TRUE);
509
 
 
510
 
               return !_ncStartNetworkResponse->is_valid_ncStartNetworkResponse;
511
 
           }
512
 
 
513
 
           /**
514
 
            * Set ncStartNetworkResponse to nill (currently the same as reset)
515
 
            */
516
 
           axis2_status_t AXIS2_CALL
517
 
           adb_ncStartNetworkResponse_set_ncStartNetworkResponse_nil(
518
 
                   adb_ncStartNetworkResponse_t* _ncStartNetworkResponse,
519
 
                   const axutil_env_t *env)
520
 
           {
521
 
               return adb_ncStartNetworkResponse_reset_ncStartNetworkResponse(_ncStartNetworkResponse, env);
522
 
           }
523
 
 
524
 
 
525