← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cluster/generated/adb_ccTerminatedInstanceType.c

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

Dustin Kirkland <kirkland@canonical.com>

* New major upstream version merge, 2.0 (r1211).
  - 01-wsdl-stubs.patch, debian/wsdl.md5sums: wsdl stubs updated.
  - 11-state-cleanup-memleakfix.patch: Removed, fixed upstream.
  - 21-eucalyptus-1.7-with-gwt-1.6.4.patch: New patch, allows 
    eucalyptus-1.7 to be built against gwt 1.6.4. Based on patch courtesy 
    of Dmitrii Zagorodnov, upstream. (LP: #597330)
* debian/eucalyptus-java-common.links: 
  - Changed symlink for groovy, point to groovy.all.jar, making compatiable 
    with groovy versions >1.7. (LP: #595421)
  - Added ant.jar & jetty-rewrite-handler.jar as they are now required.
* debian/control
  - & debian/build-jars: Added libjavassist-java and libjetty-extra-java as 
    build dependencies.
  - Added libjetty-extra-java as a dependency of eucalyptus-java-common
* The binary resulting jar's have been renamed from eucalyptus-*-1.6.2.jar
  to eucalyptus-*-main.jar:    
  - debian/eucalyptus-cc.upstart
  - debian/eucalyptus-cloud.install
  - debian/eucalyptus-common.eucalyptus.upstart
  - debian/eucalyptus-java-common.install
  - debian/eucalyptus-network.upstart
  - debian/eucalyptus-sc.install
  - debian/eucalyptus-walrus.install
* debian/eucalyptus-java-common.install: New upstream jars that have been
  installed:
  - eucalyptus-db-hsqldb-ext-main.jar
  - eucalyptus-component-main.jar
* debian/control:
  - Updated Standards Version to 3.8.4 (no change)
  - Updated the upstream Homepage to: http://open.eucalyptus.com/
  - Changed Vcs-Bzr to reflect new location of Ubuntu hosted development branch.
  - Made the Build Dependency of groovy and the binary eucalyptus-java-common
    package depend on version >=1.7.

Show diffs side-by-side

added added

removed removed

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