src/CreateConfigFile.cpp

   1
   2
   3         /**
   4          * CreateConfigFile.cpp
   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 "CreateConfigFile.h"
  11         #include <Environment.h>
  12         #include <WSFError.h>
  13
  14
  15         using namespace wso2wsf;
  16         using namespace std;
  17
  18         using namespace org_splat_ws_server_service_salome;
  19
  20                /*
  21                 * Implementation of the createConfigFile|http://salome.service.ws_server.splat.org Element
  22                 */
  23            org_splat_ws_server_service_salome::CreateConfigFile::CreateConfigFile()
  24         {
  25
  26
  27             qname = NULL;
  28
  29             isValidArgs0  = false;
  30
  31             isValidArgs1  = false;
  32
  33             isValidArgs2  = false;
  34
  35                   qname =  axutil_qname_create (Environment::getEnv(),
  36                         "createConfigFile",
  37                         "http://salome.service.ws_server.splat.org",
  38                         NULL);
  39
  40         }
  41
  42        org_splat_ws_server_service_salome::CreateConfigFile::CreateConfigFile(int64_t arg_Args0,int64_t arg_Args1,int64_t arg_Args2)
  43         {
  44
  45                    qname = NULL;
  46
  47             isValidArgs0  = true;
  48
  49             isValidArgs1  = true;
  50
  51             isValidArgs2  = true;
  52
  53                  qname =  axutil_qname_create (Environment::getEnv(),
  54                        "createConfigFile",
  55                        "http://salome.service.ws_server.splat.org",
  56                        NULL);
  57
  58                     property_Args0 = arg_Args0;
  59
  60                     property_Args1 = arg_Args1;
  61
  62                     property_Args2 = arg_Args2;
  63
  64         }
  65         org_splat_ws_server_service_salome::CreateConfigFile::~CreateConfigFile()
  66         {
  67
  68         }
  69
  70
  71
  72         bool WSF_CALL
  73         org_splat_ws_server_service_salome::CreateConfigFile::deserialize(axiom_node_t** dp_parent,bool *dp_is_early_node_valid, bool dont_care_minoccurs)
  74         {
  75           axiom_node_t *parent = *dp_parent;
  76
  77           bool status = AXIS2_SUCCESS;
  78
  79          const axis2_char_t* text_value = NULL;
  80          axutil_qname_t *mqname = NULL;
  81
  82             axutil_qname_t *element_qname = NULL;
  83
  84                axiom_node_t *first_node = NULL;
  85                bool is_early_node_valid = true;
  86                axiom_node_t *current_node = NULL;
  87                axiom_element_t *current_element = NULL;
  88
  89
  90               while(parent && axiom_node_get_node_type(parent, Environment::getEnv()) != AXIOM_ELEMENT)
  91               {
  92                   parent = axiom_node_get_next_sibling(parent, Environment::getEnv());
  93               }
  94               if (NULL == parent)
  95               {
  96                 return AXIS2_FAILURE;
  97               }
  98
  99
 100                     current_element = (axiom_element_t *)axiom_node_get_data_element(parent, Environment::getEnv());
 101                     mqname = axiom_element_get_qname(current_element, Environment::getEnv(), parent);
 102                     if (axutil_qname_equals(mqname, Environment::getEnv(), this->qname))
 103                     {
 104
 105                           first_node = axiom_node_get_first_child(parent, Environment::getEnv());
 106
 107                     }
 108                     else
 109                     {
 110                         WSF_LOG_ERROR_MSG(Environment::getEnv()->log, WSF_LOG_SI,
 111                               "Failed in building adb object for createConfigFile : "
 112                               "Expected %s but returned %s",
 113                               axutil_qname_to_string(qname, Environment::getEnv()),
 114                               axutil_qname_to_string(mqname, Environment::getEnv()));
 115
 116                         return AXIS2_FAILURE;
 117                     }
 118
 119
 120
 121                      /*
 122                       * building args0 element
 123                       */
 124
 125
 126
 127                                    current_node = first_node;
 128                                    is_early_node_valid = false;
 129
 130
 131                                     while(current_node && axiom_node_get_node_type(current_node, Environment::getEnv()) != AXIOM_ELEMENT)
 132                                     {
 133                                         current_node = axiom_node_get_next_sibling(current_node, Environment::getEnv());
 134                                     }
 135                                     if(current_node != NULL)
 136                                     {
 137                                         current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, Environment::getEnv());
 138                                         mqname = axiom_element_get_qname(current_element, Environment::getEnv(), current_node);
 139                                     }
 140
 141                                  element_qname = axutil_qname_create(Environment::getEnv(), "args0", "http://salome.service.ws_server.splat.org", NULL);
 142
 143
 144                            if (
 145                                 (current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname))))
 146                            {
 147                               if( current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname)))
 148                               {
 149                                 is_early_node_valid = true;
 150                               }
 151
 152
 153                                       text_value = axiom_element_get_text(current_element, Environment::getEnv(), current_node);
 154                                       if(text_value != NULL)
 155                                       {
 156                                             status = setArgs0(axutil_strtol(text_value, (char**)NULL, 0));
 157                                       }
 158
 159                                       else
 160                                       {
 161                                           WSF_LOG_ERROR_MSG(Environment::getEnv()->log, WSF_LOG_SI, "NULL value is set to a non nillable element args0");
 162                                           status = AXIS2_FAILURE;
 163                                       }
 164
 165                                  if(AXIS2_FAILURE ==  status)
 166                                  {
 167                                      WSF_LOG_ERROR_MSG( Environment::getEnv()->log,WSF_LOG_SI,"failed in setting the value for args0 ");
 168                                      if(element_qname)
 169                                      {
 170                                          axutil_qname_free(element_qname, Environment::getEnv());
 171                                      }
 172                                      return AXIS2_FAILURE;
 173                                  }
 174                               }
 175
 176                   if(element_qname)
 177                   {
 178                      axutil_qname_free(element_qname, Environment::getEnv());
 179                      element_qname = NULL;
 180                   }
 181
 182
 183
 184                      /*
 185                       * building args1 element
 186                       */
 187
 188
 189
 190                                     /*
 191                                      * because elements are ordered this works fine
 192                                      */
 193
 194
 195                                    if(current_node != NULL && is_early_node_valid)
 196                                    {
 197                                        current_node = axiom_node_get_next_sibling(current_node, Environment::getEnv());
 198
 199
 200                                         while(current_node && axiom_node_get_node_type(current_node, Environment::getEnv()) != AXIOM_ELEMENT)
 201                                         {
 202                                             current_node = axiom_node_get_next_sibling(current_node, Environment::getEnv());
 203                                         }
 204                                         if(current_node != NULL)
 205                                         {
 206                                             current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, Environment::getEnv());
 207                                             mqname = axiom_element_get_qname(current_element, Environment::getEnv(), current_node);
 208                                         }
 209
 210                                    }
 211                                    is_early_node_valid = false;
 212
 213                                  element_qname = axutil_qname_create(Environment::getEnv(), "args1", "http://salome.service.ws_server.splat.org", NULL);
 214
 215
 216                            if (
 217                                 (current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname))))
 218                            {
 219                               if( current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname)))
 220                               {
 221                                 is_early_node_valid = true;
 222                               }
 223
 224
 225                                       text_value = axiom_element_get_text(current_element, Environment::getEnv(), current_node);
 226                                       if(text_value != NULL)
 227                                       {
 228                                             status = setArgs1(axutil_strtol(text_value, (char**)NULL, 0));
 229                                       }
 230
 231                                       else
 232                                       {
 233                                           WSF_LOG_ERROR_MSG(Environment::getEnv()->log, WSF_LOG_SI, "NULL value is set to a non nillable element args1");
 234                                           status = AXIS2_FAILURE;
 235                                       }
 236
 237                                  if(AXIS2_FAILURE ==  status)
 238                                  {
 239                                      WSF_LOG_ERROR_MSG( Environment::getEnv()->log,WSF_LOG_SI,"failed in setting the value for args1 ");
 240                                      if(element_qname)
 241                                      {
 242                                          axutil_qname_free(element_qname, Environment::getEnv());
 243                                      }
 244                                      return AXIS2_FAILURE;
 245                                  }
 246                               }
 247
 248                   if(element_qname)
 249                   {
 250                      axutil_qname_free(element_qname, Environment::getEnv());
 251                      element_qname = NULL;
 252                   }
 253
 254
 255
 256                      /*
 257                       * building args2 element
 258                       */
 259
 260
 261
 262                                     /*
 263                                      * because elements are ordered this works fine
 264                                      */
 265
 266
 267                                    if(current_node != NULL && is_early_node_valid)
 268                                    {
 269                                        current_node = axiom_node_get_next_sibling(current_node, Environment::getEnv());
 270
 271
 272                                         while(current_node && axiom_node_get_node_type(current_node, Environment::getEnv()) != AXIOM_ELEMENT)
 273                                         {
 274                                             current_node = axiom_node_get_next_sibling(current_node, Environment::getEnv());
 275                                         }
 276                                         if(current_node != NULL)
 277                                         {
 278                                             current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, Environment::getEnv());
 279                                             mqname = axiom_element_get_qname(current_element, Environment::getEnv(), current_node);
 280                                         }
 281
 282                                    }
 283                                    is_early_node_valid = false;
 284
 285                                  element_qname = axutil_qname_create(Environment::getEnv(), "args2", "http://salome.service.ws_server.splat.org", NULL);
 286
 287
 288                            if (
 289                                 (current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname))))
 290                            {
 291                               if( current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname)))
 292                               {
 293                                 is_early_node_valid = true;
 294                               }
 295
 296
 297                                       text_value = axiom_element_get_text(current_element, Environment::getEnv(), current_node);
 298                                       if(text_value != NULL)
 299                                       {
 300                                             status = setArgs2(axutil_strtol(text_value, (char**)NULL, 0));
 301                                       }
 302
 303                                       else
 304                                       {
 305                                           WSF_LOG_ERROR_MSG(Environment::getEnv()->log, WSF_LOG_SI, "NULL value is set to a non nillable element args2");
 306                                           status = AXIS2_FAILURE;
 307                                       }
 308
 309                                  if(AXIS2_FAILURE ==  status)
 310                                  {
 311                                      WSF_LOG_ERROR_MSG( Environment::getEnv()->log,WSF_LOG_SI,"failed in setting the value for args2 ");
 312                                      if(element_qname)
 313                                      {
 314                                          axutil_qname_free(element_qname, Environment::getEnv());
 315                                      }
 316                                      return AXIS2_FAILURE;
 317                                  }
 318                               }
 319
 320                   if(element_qname)
 321                   {
 322                      axutil_qname_free(element_qname, Environment::getEnv());
 323                      element_qname = NULL;
 324                   }
 325
 326           return status;
 327        }
 328
 329           bool WSF_CALL
 330           org_splat_ws_server_service_salome::CreateConfigFile::isParticle()
 331           {
 332
 333                  return false;
 334
 335           }
 336
 337
 338           void WSF_CALL
 339           org_splat_ws_server_service_salome::CreateConfigFile::declareParentNamespaces(
 340                     axiom_element_t *parent_element,
 341                     axutil_hash_t *namespaces, int *next_ns_index)
 342           {
 343
 344                   /* Here this is an empty function, Nothing to declare */
 345
 346           }
 347
 348
 349
 350         axiom_node_t* WSF_CALL
 351         org_splat_ws_server_service_salome::CreateConfigFile::serialize(axiom_node_t *parent,
 352                         axiom_element_t *parent_element,
 353                         int parent_tag_closed,
 354                         axutil_hash_t *namespaces,
 355                         int *next_ns_index)
 356         {
 357
 358
 359
 360          axiom_node_t *current_node = NULL;
 361          int tag_closed = 0;
 362
 363
 364
 365                 axiom_namespace_t *ns1 = NULL;
 366
 367                 axis2_char_t *qname_uri = NULL;
 368                 axis2_char_t *qname_prefix = NULL;
 369                 axis2_char_t *p_prefix = NULL;
 370
 371                     axis2_char_t text_value_1[ADB_DEFAULT_DIGIT_LIMIT];
 372
 373                     axis2_char_t text_value_2[ADB_DEFAULT_DIGIT_LIMIT];
 374
 375                     axis2_char_t text_value_3[ADB_DEFAULT_DIGIT_LIMIT];
 376
 377                axis2_char_t *start_input_str = NULL;
 378                axis2_char_t *end_input_str = NULL;
 379                unsigned int start_input_str_len = 0;
 380                unsigned int end_input_str_len = 0;
 381
 382
 383                axiom_data_source_t *data_source = NULL;
 384                axutil_stream_t *stream = NULL;
 385
 386
 387                 int next_ns_index_value = 0;
 388
 389                     namespaces = axutil_hash_make(Environment::getEnv());
 390                     next_ns_index = &next_ns_index_value;
 391
 392                            ns1 = axiom_namespace_create (Environment::getEnv(),
 393                                              "http://salome.service.ws_server.splat.org",
 394                                              "n");
 395                            axutil_hash_set(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING, axutil_strdup(Environment::getEnv(), "n"));
 396
 397
 398                     parent_element = axiom_element_create (Environment::getEnv(), NULL, "createConfigFile", ns1 , &parent);
 399
 400
 401                     axiom_element_set_namespace(parent_element, Environment::getEnv(), ns1, parent);
 402
 403
 404
 405                     data_source = axiom_data_source_create(Environment::getEnv(), parent, &current_node);
 406                     stream = axiom_data_source_get_stream(data_source, Environment::getEnv());
 407
 408                        if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING)))
 409                        {
 410                            p_prefix = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 411                            sprintf(p_prefix, "n%d", (*next_ns_index)++);
 412                            axutil_hash_set(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING, p_prefix);
 413
 414                            axiom_element_declare_namespace_assume_param_ownership(parent_element, Environment::getEnv(), axiom_namespace_create (Environment::getEnv(),
 415                                             "http://salome.service.ws_server.splat.org", p_prefix));
 416                        }
 417
 418
 419                    if (!isValidArgs0)
 420                    {
 421
 422                            /* no need to complain for minoccurs=0 element */
 423
 424
 425                    }
 426                    else
 427                    {
 428                      start_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 429                                  (4 + axutil_strlen(p_prefix) +
 430                                   axutil_strlen("args0")));
 431
 432                                  /* axutil_strlen("<:>") + 1 = 4 */
 433                      end_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 434                                  (5 + axutil_strlen(p_prefix) + axutil_strlen("args0")));
 435                                   /* axutil_strlen("</:>") + 1 = 5 */
 436
 437
 438
 439
 440
 441
 442                      /*
 443                       * parsing args0 element
 444                       */
 445
 446
 447
 448                             sprintf(start_input_str, "<%s%sargs0>",
 449                                  p_prefix?p_prefix:"",
 450                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 451
 452                         start_input_str_len = axutil_strlen(start_input_str);
 453                         sprintf(end_input_str, "</%s%sargs0>",
 454                                  p_prefix?p_prefix:"",
 455                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 456                         end_input_str_len = axutil_strlen(end_input_str);
 457
 458                                sprintf (text_value_1, AXIS2_PRINTF_INT64_FORMAT_SPECIFIER, (int64_t) property_Args0);
 459
 460                            axutil_stream_write(stream, Environment::getEnv(), start_input_str, start_input_str_len);
 461
 462                            axutil_stream_write(stream, Environment::getEnv(), text_value_1, axutil_strlen(text_value_1));
 463
 464                            axutil_stream_write(stream, Environment::getEnv(), end_input_str, end_input_str_len);
 465
 466
 467                      AXIS2_FREE(Environment::getEnv()->allocator,start_input_str);
 468                      AXIS2_FREE(Environment::getEnv()->allocator,end_input_str);
 469                  }
 470
 471
 472                        if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING)))
 473                        {
 474                            p_prefix = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 475                            sprintf(p_prefix, "n%d", (*next_ns_index)++);
 476                            axutil_hash_set(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING, p_prefix);
 477
 478                            axiom_element_declare_namespace_assume_param_ownership(parent_element, Environment::getEnv(), axiom_namespace_create (Environment::getEnv(),
 479                                             "http://salome.service.ws_server.splat.org", p_prefix));
 480                        }
 481
 482
 483                    if (!isValidArgs1)
 484                    {
 485
 486                            /* no need to complain for minoccurs=0 element */
 487
 488
 489                    }
 490                    else
 491                    {
 492                      start_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 493                                  (4 + axutil_strlen(p_prefix) +
 494                                   axutil_strlen("args1")));
 495
 496                                  /* axutil_strlen("<:>") + 1 = 4 */
 497                      end_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 498                                  (5 + axutil_strlen(p_prefix) + axutil_strlen("args1")));
 499                                   /* axutil_strlen("</:>") + 1 = 5 */
 500
 501
 502
 503
 504
 505
 506                      /*
 507                       * parsing args1 element
 508                       */
 509
 510
 511
 512                             sprintf(start_input_str, "<%s%sargs1>",
 513                                  p_prefix?p_prefix:"",
 514                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 515
 516                         start_input_str_len = axutil_strlen(start_input_str);
 517                         sprintf(end_input_str, "</%s%sargs1>",
 518                                  p_prefix?p_prefix:"",
 519                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 520                         end_input_str_len = axutil_strlen(end_input_str);
 521
 522                                sprintf (text_value_2, AXIS2_PRINTF_INT64_FORMAT_SPECIFIER, (int64_t) property_Args1);
 523
 524                            axutil_stream_write(stream, Environment::getEnv(), start_input_str, start_input_str_len);
 525
 526                            axutil_stream_write(stream, Environment::getEnv(), text_value_2, axutil_strlen(text_value_2));
 527
 528                            axutil_stream_write(stream, Environment::getEnv(), end_input_str, end_input_str_len);
 529
 530
 531                      AXIS2_FREE(Environment::getEnv()->allocator,start_input_str);
 532                      AXIS2_FREE(Environment::getEnv()->allocator,end_input_str);
 533                  }
 534
 535
 536                        if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING)))
 537                        {
 538                            p_prefix = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 539                            sprintf(p_prefix, "n%d", (*next_ns_index)++);
 540                            axutil_hash_set(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING, p_prefix);
 541
 542                            axiom_element_declare_namespace_assume_param_ownership(parent_element, Environment::getEnv(), axiom_namespace_create (Environment::getEnv(),
 543                                             "http://salome.service.ws_server.splat.org", p_prefix));
 544                        }
 545
 546
 547                    if (!isValidArgs2)
 548                    {
 549
 550                            /* no need to complain for minoccurs=0 element */
 551
 552
 553                    }
 554                    else
 555                    {
 556                      start_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 557                                  (4 + axutil_strlen(p_prefix) +
 558                                   axutil_strlen("args2")));
 559
 560                                  /* axutil_strlen("<:>") + 1 = 4 */
 561                      end_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 562                                  (5 + axutil_strlen(p_prefix) + axutil_strlen("args2")));
 563                                   /* axutil_strlen("</:>") + 1 = 5 */
 564
 565
 566
 567
 568
 569
 570                      /*
 571                       * parsing args2 element
 572                       */
 573
 574
 575
 576                             sprintf(start_input_str, "<%s%sargs2>",
 577                                  p_prefix?p_prefix:"",
 578                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 579
 580                         start_input_str_len = axutil_strlen(start_input_str);
 581                         sprintf(end_input_str, "</%s%sargs2>",
 582                                  p_prefix?p_prefix:"",
 583                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 584                         end_input_str_len = axutil_strlen(end_input_str);
 585
 586                                sprintf (text_value_3, AXIS2_PRINTF_INT64_FORMAT_SPECIFIER, (int64_t) property_Args2);
 587
 588                            axutil_stream_write(stream, Environment::getEnv(), start_input_str, start_input_str_len);
 589
 590                            axutil_stream_write(stream, Environment::getEnv(), text_value_3, axutil_strlen(text_value_3));
 591
 592                            axutil_stream_write(stream, Environment::getEnv(), end_input_str, end_input_str_len);
 593
 594
 595                      AXIS2_FREE(Environment::getEnv()->allocator,start_input_str);
 596                      AXIS2_FREE(Environment::getEnv()->allocator,end_input_str);
 597                  }
 598
 599
 600                    if(namespaces)
 601                    {
 602                        axutil_hash_index_t *hi;
 603                        void *val;
 604                        for (hi = axutil_hash_first(namespaces, Environment::getEnv()); hi; hi = axutil_hash_next(Environment::getEnv(), hi))
 605                        {
 606                            axutil_hash_this(hi, NULL, NULL, &val);
 607                            AXIS2_FREE(Environment::getEnv()->allocator, val);
 608                        }
 609                        axutil_hash_free(namespaces, Environment::getEnv());
 610                    }
 611
 612
 613             return parent;
 614         }
 615
 616
 617
 618
 619             /**
 620              * Getter for args0 by  Property Number 1
 621              */
 622             int64_t WSF_CALL
 623             org_splat_ws_server_service_salome::CreateConfigFile::getProperty1()
 624             {
 625                 return getArgs0();
 626             }
 627
 628             /**
 629              * getter for args0.
 630              */
 631             int64_t WSF_CALL
 632             org_splat_ws_server_service_salome::CreateConfigFile::getArgs0()
 633              {
 634                 return property_Args0;
 635              }
 636
 637             /**
 638              * setter for args0
 639              */
 640             bool WSF_CALL
 641             org_splat_ws_server_service_salome::CreateConfigFile::setArgs0(
 642                     const int64_t  arg_Args0)
 643              {
 644
 645
 646                 if(isValidArgs0 &&
 647                         arg_Args0 == property_Args0)
 648                 {
 649
 650                     return true;
 651                 }
 652
 653
 654
 655
 656                 resetArgs0();
 657
 658
 659                         property_Args0 = arg_Args0;
 660                         isValidArgs0 = true;
 661
 662                 return true;
 663              }
 664
 665
 666
 667            /**
 668             * resetter for args0
 669             */
 670            bool WSF_CALL
 671            org_splat_ws_server_service_salome::CreateConfigFile::resetArgs0()
 672            {
 673                int i = 0;
 674                int count = 0;
 675
 676
 677
 678                isValidArgs0 = false;
 679                return true;
 680            }
 681
 682            /**
 683             * Check whether args0 is nill
 684             */
 685            bool WSF_CALL
 686            org_splat_ws_server_service_salome::CreateConfigFile::isArgs0Nil()
 687            {
 688                return !isValidArgs0;
 689            }
 690
 691            /**
 692             * Set args0 to nill (currently the same as reset)
 693             */
 694            bool WSF_CALL
 695            org_splat_ws_server_service_salome::CreateConfigFile::setArgs0Nil()
 696            {
 697                return resetArgs0();
 698            }
 699
 700
 701
 702             /**
 703              * Getter for args1 by  Property Number 2
 704              */
 705             int64_t WSF_CALL
 706             org_splat_ws_server_service_salome::CreateConfigFile::getProperty2()
 707             {
 708                 return getArgs1();
 709             }
 710
 711             /**
 712              * getter for args1.
 713              */
 714             int64_t WSF_CALL
 715             org_splat_ws_server_service_salome::CreateConfigFile::getArgs1()
 716              {
 717                 return property_Args1;
 718              }
 719
 720             /**
 721              * setter for args1
 722              */
 723             bool WSF_CALL
 724             org_splat_ws_server_service_salome::CreateConfigFile::setArgs1(
 725                     const int64_t  arg_Args1)
 726              {
 727
 728
 729                 if(isValidArgs1 &&
 730                         arg_Args1 == property_Args1)
 731                 {
 732
 733                     return true;
 734                 }
 735
 736
 737
 738
 739                 resetArgs1();
 740
 741
 742                         property_Args1 = arg_Args1;
 743                         isValidArgs1 = true;
 744
 745                 return true;
 746              }
 747
 748
 749
 750            /**
 751             * resetter for args1
 752             */
 753            bool WSF_CALL
 754            org_splat_ws_server_service_salome::CreateConfigFile::resetArgs1()
 755            {
 756                int i = 0;
 757                int count = 0;
 758
 759
 760
 761                isValidArgs1 = false;
 762                return true;
 763            }
 764
 765            /**
 766             * Check whether args1 is nill
 767             */
 768            bool WSF_CALL
 769            org_splat_ws_server_service_salome::CreateConfigFile::isArgs1Nil()
 770            {
 771                return !isValidArgs1;
 772            }
 773
 774            /**
 775             * Set args1 to nill (currently the same as reset)
 776             */
 777            bool WSF_CALL
 778            org_splat_ws_server_service_salome::CreateConfigFile::setArgs1Nil()
 779            {
 780                return resetArgs1();
 781            }
 782
 783
 784
 785             /**
 786              * Getter for args2 by  Property Number 3
 787              */
 788             int64_t WSF_CALL
 789             org_splat_ws_server_service_salome::CreateConfigFile::getProperty3()
 790             {
 791                 return getArgs2();
 792             }
 793
 794             /**
 795              * getter for args2.
 796              */
 797             int64_t WSF_CALL
 798             org_splat_ws_server_service_salome::CreateConfigFile::getArgs2()
 799              {
 800                 return property_Args2;
 801              }
 802
 803             /**
 804              * setter for args2
 805              */
 806             bool WSF_CALL
 807             org_splat_ws_server_service_salome::CreateConfigFile::setArgs2(
 808                     const int64_t  arg_Args2)
 809              {
 810
 811
 812                 if(isValidArgs2 &&
 813                         arg_Args2 == property_Args2)
 814                 {
 815
 816                     return true;
 817                 }
 818
 819
 820
 821
 822                 resetArgs2();
 823
 824
 825                         property_Args2 = arg_Args2;
 826                         isValidArgs2 = true;
 827
 828                 return true;
 829              }
 830
 831
 832
 833            /**
 834             * resetter for args2
 835             */
 836            bool WSF_CALL
 837            org_splat_ws_server_service_salome::CreateConfigFile::resetArgs2()
 838            {
 839                int i = 0;
 840                int count = 0;
 841
 842
 843
 844                isValidArgs2 = false;
 845                return true;
 846            }
 847
 848            /**
 849             * Check whether args2 is nill
 850             */
 851            bool WSF_CALL
 852            org_splat_ws_server_service_salome::CreateConfigFile::isArgs2Nil()
 853            {
 854                return !isValidArgs2;
 855            }
 856
 857            /**
 858             * Set args2 to nill (currently the same as reset)
 859             */
 860            bool WSF_CALL
 861            org_splat_ws_server_service_salome::CreateConfigFile::setArgs2Nil()
 862            {
 863                return resetArgs2();
 864            }
 865
 866
 867