src/CheckIn.cpp

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