src/PutFile.cpp

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