src/SimanSalomeServiceStub.cpp

   1
   2       /**
   3        * SimanSalomeServiceStub.cpp
   4        *
   5        * This file was auto-generated from WSDL for "SimanSalomeService|http://salome.service.ws_server.splat.org" service
   6        * by the Apache Axis2/Java version: 1.0  Built on : Nov 21, 2012 (01:42:27 MSK)
   7        */
   8
   9       #include "SimanSalomeServiceStub.h"
  10       #include "ISimanSalomeServiceCallback.h"
  11       #include <axis2_msg.h>
  12       #include <axis2_policy_include.h>
  13       #include <neethi_engine.h>
  14       #include <Stub.h>
  15       #include <Environment.h>
  16       #include <WSFError.h>
  17
  18       using namespace std;
  19       using namespace wso2wsf;
  20
  21       using namespace org_splat_ws_server_service_salome;
  22
  23       /**
  24        * SimanSalomeServiceStub CPP implementation
  25        */
  26        SimanSalomeServiceStub::SimanSalomeServiceStub(std::string& clientHome)
  27         {
  28                 if(clientHome.empty())
  29                 {
  30                    cout<<"Please specify the client home";
  31                 }
  32                 std::string endpointUri= getEndpointUriOfSimanSalomeService();
  33
  34                 init(clientHome,endpointUri);
  35
  36                 populateServicesForSimanSalomeService();
  37
  38
  39         }
  40
  41
  42       SimanSalomeServiceStub::SimanSalomeServiceStub(std::string& clientHome,std::string& endpointURI)
  43       {
  44          std::string endpointUri;
  45
  46          if(clientHome.empty())
  47          {
  48             cout<<"Please specify the client home";
  49          }
  50          endpointUri = endpointURI;
  51
  52          if (endpointUri.empty())
  53          {
  54             endpointUri = getEndpointUriOfSimanSalomeService();
  55          }
  56
  57
  58          init(clientHome,endpointUri);
  59
  60          populateServicesForSimanSalomeService();
  61
  62       }
  63
  64
  65       void WSF_CALL
  66       SimanSalomeServiceStub::populateServicesForSimanSalomeService()
  67       {
  68          axis2_svc_client_t *svc_client = NULL;
  69          axutil_qname_t *svc_qname =  NULL;
  70          axutil_qname_t *op_qname =  NULL;
  71          axis2_svc_t *svc = NULL;
  72          axis2_op_t *op = NULL;
  73          axis2_op_t *annon_op = NULL;
  74          axis2_msg_t *msg_out = NULL;
  75          axis2_msg_t *msg_in = NULL;
  76          axis2_msg_t *msg_out_fault = NULL;
  77          axis2_msg_t *msg_in_fault = NULL;
  78          axis2_policy_include_t *policy_include = NULL;
  79
  80          axis2_desc_t *desc = NULL;
  81          axiom_node_t *policy_node = NULL;
  82          axiom_element_t *policy_root_ele = NULL;
  83          neethi_policy_t *neethi_policy = NULL;
  84
  85
  86          /* Modifying the Service */
  87          svc_client = serviceClient->getAxis2SvcClient();
  88          svc = (axis2_svc_t*)axis2_svc_client_get_svc( svc_client, Environment::getEnv() );
  89
  90          annon_op = axis2_svc_get_op_with_name(svc, Environment::getEnv(), AXIS2_ANON_OUT_IN_OP);
  91          msg_out = axis2_op_get_msg(annon_op, Environment::getEnv(), AXIS2_MSG_OUT);
  92          msg_in = axis2_op_get_msg(annon_op, Environment::getEnv(), AXIS2_MSG_IN);
  93          msg_out_fault = axis2_op_get_msg(annon_op, Environment::getEnv(), AXIS2_MSG_OUT_FAULT);
  94          msg_in_fault = axis2_op_get_msg(annon_op, Environment::getEnv(), AXIS2_MSG_IN_FAULT);
  95
  96          svc_qname = axutil_qname_create(Environment::getEnv(),"SimanSalomeService" ,NULL, NULL);
  97          axis2_svc_set_qname (svc, Environment::getEnv(), svc_qname);
  98                  axutil_qname_free(svc_qname,Environment::getEnv());
  99
 100          /* creating the operations*/
 101
 102
 103            op_qname = axutil_qname_create(Environment::getEnv(),
 104                                          "createConfigFile" ,
 105                                          "http://salome.service.ws_server.splat.org",
 106                                          NULL);
 107            op = axis2_op_create_with_qname(Environment::getEnv(), op_qname);
 108            axutil_qname_free(op_qname,Environment::getEnv());
 109
 110
 111            axis2_op_set_msg_exchange_pattern(op, Environment::getEnv(), AXIS2_MEP_URI_OUT_IN);
 112
 113            axis2_msg_increment_ref(msg_out, Environment::getEnv());
 114            axis2_msg_increment_ref(msg_in, Environment::getEnv());
 115            axis2_msg_increment_ref(msg_out_fault, Environment::getEnv());
 116            axis2_msg_increment_ref(msg_in_fault, Environment::getEnv());
 117            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT, msg_out);
 118            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN, msg_in);
 119            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT_FAULT, msg_out_fault);
 120            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN_FAULT, msg_in_fault);
 121
 122
 123            axis2_svc_add_op(svc, Environment::getEnv(), op);
 124
 125            op_qname = axutil_qname_create(Environment::getEnv(),
 126                                          "putFile" ,
 127                                          "http://salome.service.ws_server.splat.org",
 128                                          NULL);
 129            op = axis2_op_create_with_qname(Environment::getEnv(), op_qname);
 130            axutil_qname_free(op_qname,Environment::getEnv());
 131
 132
 133            axis2_op_set_msg_exchange_pattern(op, Environment::getEnv(), AXIS2_MEP_URI_OUT_IN);
 134
 135            axis2_msg_increment_ref(msg_out, Environment::getEnv());
 136            axis2_msg_increment_ref(msg_in, Environment::getEnv());
 137            axis2_msg_increment_ref(msg_out_fault, Environment::getEnv());
 138            axis2_msg_increment_ref(msg_in_fault, Environment::getEnv());
 139            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT, msg_out);
 140            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN, msg_in);
 141            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT_FAULT, msg_out_fault);
 142            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN_FAULT, msg_in_fault);
 143
 144
 145            axis2_svc_add_op(svc, Environment::getEnv(), op);
 146
 147            op_qname = axutil_qname_create(Environment::getEnv(),
 148                                          "checkIn" ,
 149                                          "http://salome.service.ws_server.splat.org",
 150                                          NULL);
 151            op = axis2_op_create_with_qname(Environment::getEnv(), op_qname);
 152            axutil_qname_free(op_qname,Environment::getEnv());
 153
 154
 155            axis2_op_set_msg_exchange_pattern(op, Environment::getEnv(), AXIS2_MEP_URI_OUT_IN);
 156
 157            axis2_msg_increment_ref(msg_out, Environment::getEnv());
 158            axis2_msg_increment_ref(msg_in, Environment::getEnv());
 159            axis2_msg_increment_ref(msg_out_fault, Environment::getEnv());
 160            axis2_msg_increment_ref(msg_in_fault, Environment::getEnv());
 161            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT, msg_out);
 162            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN, msg_in);
 163            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT_FAULT, msg_out_fault);
 164            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN_FAULT, msg_in_fault);
 165
 166
 167            axis2_svc_add_op(svc, Environment::getEnv(), op);
 168
 169            op_qname = axutil_qname_create(Environment::getEnv(),
 170                                          "getFile" ,
 171                                          "http://salome.service.ws_server.splat.org",
 172                                          NULL);
 173            op = axis2_op_create_with_qname(Environment::getEnv(), op_qname);
 174            axutil_qname_free(op_qname,Environment::getEnv());
 175
 176
 177            axis2_op_set_msg_exchange_pattern(op, Environment::getEnv(), AXIS2_MEP_URI_OUT_IN);
 178
 179            axis2_msg_increment_ref(msg_out, Environment::getEnv());
 180            axis2_msg_increment_ref(msg_in, Environment::getEnv());
 181            axis2_msg_increment_ref(msg_out_fault, Environment::getEnv());
 182            axis2_msg_increment_ref(msg_in_fault, Environment::getEnv());
 183            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT, msg_out);
 184            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN, msg_in);
 185            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_OUT_FAULT, msg_out_fault);
 186            axis2_op_add_msg(op, Environment::getEnv(), AXIS2_MSG_IN_FAULT, msg_in_fault);
 187
 188
 189            axis2_svc_add_op(svc, Environment::getEnv(), op);
 190
 191       }
 192
 193       /**
 194        *return end point picked from wsdl
 195        */
 196       std::string WSF_CALL
 197       SimanSalomeServiceStub::getEndpointUriOfSimanSalomeService()
 198       {
 199         std::string endpoint_uri;
 200         /* set the address from here */
 201
 202         endpoint_uri = string("http://localhost:8080/Siman-WS/services/SimanSalomeService.SimanSalomeServiceHttpSoap12Endpoint/");
 203
 204         return endpoint_uri;
 205       }
 206
 207
 208
 209          /**
 210           * Auto generated method signature
 211           * For "createConfigFile|http://salome.service.ws_server.splat.org" operation.
 212           *
 213           * @param _createConfigFile of the org_splat_ws_server_service_salome::CreateConfigFile
 214           *
 215           * @return org_splat_ws_server_service_salome::CreateConfigFileResponse*
 216           */
 217
 218          org_splat_ws_server_service_salome::CreateConfigFileResponse* WSF_CALL SimanSalomeServiceStub::createConfigFile(org_splat_ws_server_service_salome::CreateConfigFile*  _createConfigFile)
 219          {
 220             axis2_svc_client_t *svc_client = NULL;
 221             axis2_options_t *options = NULL;
 222             axiom_node_t *ret_node = NULL;
 223
 224             const axis2_char_t *soap_action = NULL;
 225             axutil_qname_t *op_qname =  NULL;
 226             axiom_node_t *payload = NULL;
 227             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 228             axutil_string_t *soap_act = NULL;
 229
 230             org_splat_ws_server_service_salome::CreateConfigFileResponse* ret_val;
 231
 232                                 payload = _createConfigFile->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
 233
 234             svc_client = serviceClient->getAxis2SvcClient();
 235
 236
 237
 238
 239
 240             options = clientOptions->getAxis2Options();
 241             if (NULL == options)
 242             {
 243                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 244                 AXIS2_LOG_ERROR(Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
 245                 return (org_splat_ws_server_service_salome::CreateConfigFileResponse*)NULL;
 246             }
 247             soap_act = axis2_options_get_soap_action( options, Environment::getEnv() );
 248             if (NULL == soap_act)
 249             {
 250               is_soap_act_set = AXIS2_FALSE;
 251               soap_action = "urn:createConfigFile";
 252               soap_act = axutil_string_create(Environment::getEnv(), "urn:createConfigFile");
 253               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
 254             }
 255
 256
 257             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
 258
 259             ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, Environment::getEnv(), op_qname, payload);
 260
 261             if (!is_soap_act_set)
 262             {
 263
 264               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
 265
 266               axis2_options_set_action( options, Environment::getEnv(), NULL);
 267             }
 268             if(soap_act)
 269             {
 270               axutil_string_free(soap_act, Environment::getEnv());
 271             }
 272
 273
 274                     if ( NULL == ret_node )
 275                     {
 276                         return (org_splat_ws_server_service_salome::CreateConfigFileResponse*)NULL;
 277                     }
 278                     ret_val = new org_splat_ws_server_service_salome::CreateConfigFileResponse();
 279
 280                     if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 281                     {
 282                         if(ret_val != NULL)
 283                         {
 284                            delete ret_val;
 285                         }
 286
 287                         AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the _deserialize: "
 288                                                                 "This should be due to an invalid XML");
 289                         return (org_splat_ws_server_service_salome::CreateConfigFileResponse*)NULL;
 290                     }
 291
 292
 293                             return ret_val;
 294
 295         }
 296
 297          /**
 298           * Auto generated method signature
 299           * For "putFile|http://salome.service.ws_server.splat.org" operation.
 300           *
 301           * @param _putFile of the org_splat_ws_server_service_salome::PutFile
 302           *
 303           * @return org_splat_ws_server_service_salome::PutFileResponse*
 304           */
 305
 306          org_splat_ws_server_service_salome::PutFileResponse* WSF_CALL SimanSalomeServiceStub::putFile(org_splat_ws_server_service_salome::PutFile*  _putFile)
 307          {
 308             axis2_svc_client_t *svc_client = NULL;
 309             axis2_options_t *options = NULL;
 310             axiom_node_t *ret_node = NULL;
 311
 312             const axis2_char_t *soap_action = NULL;
 313             axutil_qname_t *op_qname =  NULL;
 314             axiom_node_t *payload = NULL;
 315             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 316             axutil_string_t *soap_act = NULL;
 317
 318             org_splat_ws_server_service_salome::PutFileResponse* ret_val;
 319
 320                                 payload = _putFile->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
 321
 322             svc_client = serviceClient->getAxis2SvcClient();
 323
 324
 325
 326
 327
 328             options = clientOptions->getAxis2Options();
 329             if (NULL == options)
 330             {
 331                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 332                 AXIS2_LOG_ERROR(Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
 333                 return (org_splat_ws_server_service_salome::PutFileResponse*)NULL;
 334             }
 335             soap_act = axis2_options_get_soap_action( options, Environment::getEnv() );
 336             if (NULL == soap_act)
 337             {
 338               is_soap_act_set = AXIS2_FALSE;
 339               soap_action = "urn:putFile";
 340               soap_act = axutil_string_create(Environment::getEnv(), "urn:putFile");
 341               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
 342             }
 343
 344
 345             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
 346
 347             ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, Environment::getEnv(), op_qname, payload);
 348
 349             if (!is_soap_act_set)
 350             {
 351
 352               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
 353
 354               axis2_options_set_action( options, Environment::getEnv(), NULL);
 355             }
 356             if(soap_act)
 357             {
 358               axutil_string_free(soap_act, Environment::getEnv());
 359             }
 360
 361
 362                     if ( NULL == ret_node )
 363                     {
 364                         return (org_splat_ws_server_service_salome::PutFileResponse*)NULL;
 365                     }
 366                     ret_val = new org_splat_ws_server_service_salome::PutFileResponse();
 367
 368                     if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 369                     {
 370                         if(ret_val != NULL)
 371                         {
 372                            delete ret_val;
 373                         }
 374
 375                         AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the _deserialize: "
 376                                                                 "This should be due to an invalid XML");
 377                         return (org_splat_ws_server_service_salome::PutFileResponse*)NULL;
 378                     }
 379
 380
 381                             return ret_val;
 382
 383         }
 384
 385          /**
 386           * Auto generated method signature
 387           * For "checkIn|http://salome.service.ws_server.splat.org" operation.
 388           *
 389           * @param _checkIn of the org_splat_ws_server_service_salome::CheckIn
 390           *
 391           * @return org_splat_ws_server_service_salome::CheckInResponse*
 392           */
 393
 394          org_splat_ws_server_service_salome::CheckInResponse* WSF_CALL SimanSalomeServiceStub::checkIn(org_splat_ws_server_service_salome::CheckIn*  _checkIn)
 395          {
 396             axis2_svc_client_t *svc_client = NULL;
 397             axis2_options_t *options = NULL;
 398             axiom_node_t *ret_node = NULL;
 399
 400             const axis2_char_t *soap_action = NULL;
 401             axutil_qname_t *op_qname =  NULL;
 402             axiom_node_t *payload = NULL;
 403             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 404             axutil_string_t *soap_act = NULL;
 405
 406             org_splat_ws_server_service_salome::CheckInResponse* ret_val;
 407
 408                                 payload = _checkIn->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
 409
 410             svc_client = serviceClient->getAxis2SvcClient();
 411
 412
 413
 414
 415
 416             options = clientOptions->getAxis2Options();
 417             if (NULL == options)
 418             {
 419                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 420                 AXIS2_LOG_ERROR(Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
 421                 return (org_splat_ws_server_service_salome::CheckInResponse*)NULL;
 422             }
 423             soap_act = axis2_options_get_soap_action( options, Environment::getEnv() );
 424             if (NULL == soap_act)
 425             {
 426               is_soap_act_set = AXIS2_FALSE;
 427               soap_action = "urn:checkIn";
 428               soap_act = axutil_string_create(Environment::getEnv(), "urn:checkIn");
 429               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
 430             }
 431
 432
 433             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
 434
 435             ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, Environment::getEnv(), op_qname, payload);
 436
 437             if (!is_soap_act_set)
 438             {
 439
 440               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
 441
 442               axis2_options_set_action( options, Environment::getEnv(), NULL);
 443             }
 444             if(soap_act)
 445             {
 446               axutil_string_free(soap_act, Environment::getEnv());
 447             }
 448
 449
 450                     if ( NULL == ret_node )
 451                     {
 452                         return (org_splat_ws_server_service_salome::CheckInResponse*)NULL;
 453                     }
 454                     ret_val = new org_splat_ws_server_service_salome::CheckInResponse();
 455
 456                     if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 457                     {
 458                         if(ret_val != NULL)
 459                         {
 460                            delete ret_val;
 461                         }
 462
 463                         AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the _deserialize: "
 464                                                                 "This should be due to an invalid XML");
 465                         return (org_splat_ws_server_service_salome::CheckInResponse*)NULL;
 466                     }
 467
 468
 469                             return ret_val;
 470
 471         }
 472
 473          /**
 474           * Auto generated method signature
 475           * For "getFile|http://salome.service.ws_server.splat.org" operation.
 476           *
 477           * @param _getFile of the org_splat_ws_server_service_salome::GetFile
 478           *
 479           * @return org_splat_ws_server_service_salome::GetFileResponse*
 480           */
 481
 482          org_splat_ws_server_service_salome::GetFileResponse* WSF_CALL SimanSalomeServiceStub::getFile(org_splat_ws_server_service_salome::GetFile*  _getFile)
 483          {
 484             axis2_svc_client_t *svc_client = NULL;
 485             axis2_options_t *options = NULL;
 486             axiom_node_t *ret_node = NULL;
 487
 488             const axis2_char_t *soap_action = NULL;
 489             axutil_qname_t *op_qname =  NULL;
 490             axiom_node_t *payload = NULL;
 491             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 492             axutil_string_t *soap_act = NULL;
 493
 494             org_splat_ws_server_service_salome::GetFileResponse* ret_val;
 495
 496                                 payload = _getFile->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
 497
 498             svc_client = serviceClient->getAxis2SvcClient();
 499
 500
 501
 502
 503
 504             options = clientOptions->getAxis2Options();
 505             if (NULL == options)
 506             {
 507                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 508                 AXIS2_LOG_ERROR(Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
 509                 return (org_splat_ws_server_service_salome::GetFileResponse*)NULL;
 510             }
 511             soap_act = axis2_options_get_soap_action( options, Environment::getEnv() );
 512             if (NULL == soap_act)
 513             {
 514               is_soap_act_set = AXIS2_FALSE;
 515               soap_action = "urn:getFile";
 516               soap_act = axutil_string_create(Environment::getEnv(), "urn:getFile");
 517               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
 518             }
 519
 520
 521             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
 522
 523             ret_node =  axis2_svc_client_send_receive_with_op_qname( svc_client, Environment::getEnv(), op_qname, payload);
 524
 525             if (!is_soap_act_set)
 526             {
 527
 528               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
 529
 530               axis2_options_set_action( options, Environment::getEnv(), NULL);
 531             }
 532             if(soap_act)
 533             {
 534               axutil_string_free(soap_act, Environment::getEnv());
 535             }
 536
 537
 538                     if ( NULL == ret_node )
 539                     {
 540                         return (org_splat_ws_server_service_salome::GetFileResponse*)NULL;
 541                     }
 542                     ret_val = new org_splat_ws_server_service_salome::GetFileResponse();
 543
 544                     if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 545                     {
 546                         if(ret_val != NULL)
 547                         {
 548                            delete ret_val;
 549                         }
 550
 551                         AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the _deserialize: "
 552                                                                 "This should be due to an invalid XML");
 553                         return (org_splat_ws_server_service_salome::GetFileResponse*)NULL;
 554                     }
 555
 556
 557                             return ret_val;
 558
 559         }
 560
 561
 562         struct axis2_stub_SimanSalomeService_createConfigFile_callback_data
 563         {
 564             ISimanSalomeServiceCallback *callback;
 565
 566         };
 567
 568         static axis2_status_t WSF_CALL axis2_stub_on_error_SimanSalomeService_createConfigFile(axis2_callback_t *axis_callback, const axutil_env_t *env, int exception)
 569         {
 570             struct axis2_stub_SimanSalomeService_createConfigFile_callback_data* callback_data = NULL;
 571             callback_data = (struct axis2_stub_SimanSalomeService_createConfigFile_callback_data*)axis2_callback_get_data(axis_callback);
 572
 573             ISimanSalomeServiceCallback* callback = NULL;
 574             callback = callback_data->callback;
 575             callback->receiveError_createConfigFile(exception);
 576             return AXIS2_SUCCESS;
 577         }
 578
 579         axis2_status_t  AXIS2_CALL axis2_stub_on_complete_SimanSalomeService_createConfigFile(axis2_callback_t *axis_callback, const axutil_env_t *env)
 580         {
 581             struct axis2_stub_SimanSalomeService_createConfigFile_callback_data* callback_data = NULL;
 582             axis2_status_t status = AXIS2_SUCCESS;
 583             org_splat_ws_server_service_salome::CreateConfigFileResponse* ret_val;
 584
 585
 586             axiom_node_t *ret_node = NULL;
 587             axiom_soap_envelope_t *soap_envelope = NULL;
 588
 589
 590
 591             ISimanSalomeServiceCallback *callback = NULL;
 592
 593             callback_data = (struct axis2_stub_SimanSalomeService_createConfigFile_callback_data*)axis2_callback_get_data(axis_callback);
 594
 595             callback = callback_data->callback;
 596
 597             soap_envelope = axis2_callback_get_envelope(axis_callback, Environment::getEnv());
 598             if(soap_envelope)
 599             {
 600                 axiom_soap_body_t *soap_body;
 601                 soap_body = axiom_soap_envelope_get_body(soap_envelope, Environment::getEnv());
 602                 if(soap_body)
 603                 {
 604                     axiom_soap_fault_t *soap_fault = NULL;
 605                     axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, Environment::getEnv());
 606
 607                       if(body_node)
 608                     {
 609                         ret_node = axiom_node_get_first_child(body_node, Environment::getEnv());
 610                     }
 611                 }
 612
 613
 614             }
 615
 616
 617
 618                     if(ret_node != NULL)
 619                     {
 620                         ret_val = new org_splat_ws_server_service_salome::CreateConfigFileResponse();
 621
 622                         if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 623                         {
 624                             WSF_LOG_ERROR_MSG( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the LendResponse_deserialize: "
 625                                                                     "This should be due to an invalid XML");
 626                             delete ret_val;
 627                             ret_val = NULL;
 628                         }
 629                      }
 630                      else
 631                      {
 632                          ret_val = NULL;
 633                      }
 634
 635
 636                      callback->receiveResult_createConfigFile(ret_val);
 637
 638
 639             if(callback_data)
 640             {
 641                 AXIS2_FREE(Environment::getEnv()->allocator, callback_data);
 642             }
 643             return AXIS2_SUCCESS;
 644         }
 645
 646         /**
 647           * auto generated method signature for asynchronous invocations
 648           * for "createConfigFile|http://salome.service.ws_server.splat.org" operation.
 649           * @param stub The stub
 650           * @param env environment ( mandatory)
 651           * @param _createConfigFile of the org_splat_ws_server_service_salome::CreateConfigFile
 652           * @param user_data user data to be accessed by the callbacks
 653           * @param on_complete callback to handle on complete
 654           * @param on_error callback to handle on error
 655           */
 656
 657          void WSF_CALL
 658         SimanSalomeServiceStub::start_createConfigFile(org_splat_ws_server_service_salome::CreateConfigFile*  _createConfigFile,
 659                                 ISimanSalomeServiceCallback* cb)
 660          {
 661
 662             axis2_callback_t *callback = NULL;
 663
 664             axis2_svc_client_t *svc_client = NULL;
 665             axis2_options_t *options = NULL;
 666
 667             const axis2_char_t *soap_action = NULL;
 668             axiom_node_t *payload = NULL;
 669
 670             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 671             axutil_string_t *soap_act = NULL;
 672
 673
 674
 675             struct axis2_stub_SimanSalomeService_createConfigFile_callback_data *callback_data;
 676
 677             callback_data = (struct axis2_stub_SimanSalomeService_createConfigFile_callback_data*) AXIS2_MALLOC(Environment::getEnv()->allocator,
 678                                     sizeof(struct axis2_stub_SimanSalomeService_createConfigFile_callback_data));
 679             if(NULL == callback_data)
 680             {
 681                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
 682                 AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "Can not allocate memory for the callback data structures");
 683                 return;
 684             }
 685
 686
 687
 688                                 payload = _createConfigFile->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
 689
 690
 691             svc_client =   serviceClient->getAxis2SvcClient();
 692
 693
 694
 695
 696
 697             options = clientOptions->getAxis2Options();
 698             if (NULL == options)
 699             {
 700               AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 701               AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
 702               return;
 703             }
 704
 705             soap_act =axis2_options_get_soap_action (options, Environment::getEnv());
 706             if (NULL == soap_act)
 707             {
 708               is_soap_act_set = AXIS2_FALSE;
 709               soap_action = "urn:createConfigFile";
 710               soap_act = axutil_string_create(Environment::getEnv(), "urn:createConfigFile");
 711               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
 712             }
 713
 714             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
 715
 716
 717             callback = axis2_callback_create(Environment::getEnv());
 718             /* Set our on_complete function pointer to the callback object */
 719             axis2_callback_set_on_complete(callback, axis2_stub_on_complete_SimanSalomeService_createConfigFile);
 720             /* Set our on_error function pointer to the callback object */
 721             axis2_callback_set_on_error(callback, axis2_stub_on_error_SimanSalomeService_createConfigFile);
 722
 723             callback_data->callback = cb;
 724             axis2_callback_set_data(callback, (void*)callback_data);
 725
 726             /* Send request */
 727             axis2_svc_client_send_receive_non_blocking(svc_client, Environment::getEnv(), payload, callback);
 728
 729             if (!is_soap_act_set)
 730             {
 731
 732               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
 733
 734               axis2_options_set_action(options, Environment::getEnv(), NULL);
 735             }
 736          }
 737
 738
 739
 740         struct axis2_stub_SimanSalomeService_putFile_callback_data
 741         {
 742             ISimanSalomeServiceCallback *callback;
 743
 744         };
 745
 746         static axis2_status_t WSF_CALL axis2_stub_on_error_SimanSalomeService_putFile(axis2_callback_t *axis_callback, const axutil_env_t *env, int exception)
 747         {
 748             struct axis2_stub_SimanSalomeService_putFile_callback_data* callback_data = NULL;
 749             callback_data = (struct axis2_stub_SimanSalomeService_putFile_callback_data*)axis2_callback_get_data(axis_callback);
 750
 751             ISimanSalomeServiceCallback* callback = NULL;
 752             callback = callback_data->callback;
 753             callback->receiveError_putFile(exception);
 754             return AXIS2_SUCCESS;
 755         }
 756
 757         axis2_status_t  AXIS2_CALL axis2_stub_on_complete_SimanSalomeService_putFile(axis2_callback_t *axis_callback, const axutil_env_t *env)
 758         {
 759             struct axis2_stub_SimanSalomeService_putFile_callback_data* callback_data = NULL;
 760             axis2_status_t status = AXIS2_SUCCESS;
 761             org_splat_ws_server_service_salome::PutFileResponse* ret_val;
 762
 763
 764             axiom_node_t *ret_node = NULL;
 765             axiom_soap_envelope_t *soap_envelope = NULL;
 766
 767
 768
 769             ISimanSalomeServiceCallback *callback = NULL;
 770
 771             callback_data = (struct axis2_stub_SimanSalomeService_putFile_callback_data*)axis2_callback_get_data(axis_callback);
 772
 773             callback = callback_data->callback;
 774
 775             soap_envelope = axis2_callback_get_envelope(axis_callback, Environment::getEnv());
 776             if(soap_envelope)
 777             {
 778                 axiom_soap_body_t *soap_body;
 779                 soap_body = axiom_soap_envelope_get_body(soap_envelope, Environment::getEnv());
 780                 if(soap_body)
 781                 {
 782                     axiom_soap_fault_t *soap_fault = NULL;
 783                     axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, Environment::getEnv());
 784
 785                       if(body_node)
 786                     {
 787                         ret_node = axiom_node_get_first_child(body_node, Environment::getEnv());
 788                     }
 789                 }
 790
 791
 792             }
 793
 794
 795
 796                     if(ret_node != NULL)
 797                     {
 798                         ret_val = new org_splat_ws_server_service_salome::PutFileResponse();
 799
 800                         if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 801                         {
 802                             WSF_LOG_ERROR_MSG( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the LendResponse_deserialize: "
 803                                                                     "This should be due to an invalid XML");
 804                             delete ret_val;
 805                             ret_val = NULL;
 806                         }
 807                      }
 808                      else
 809                      {
 810                          ret_val = NULL;
 811                      }
 812
 813
 814                      callback->receiveResult_putFile(ret_val);
 815
 816
 817             if(callback_data)
 818             {
 819                 AXIS2_FREE(Environment::getEnv()->allocator, callback_data);
 820             }
 821             return AXIS2_SUCCESS;
 822         }
 823
 824         /**
 825           * auto generated method signature for asynchronous invocations
 826           * for "putFile|http://salome.service.ws_server.splat.org" operation.
 827           * @param stub The stub
 828           * @param env environment ( mandatory)
 829           * @param _putFile of the org_splat_ws_server_service_salome::PutFile
 830           * @param user_data user data to be accessed by the callbacks
 831           * @param on_complete callback to handle on complete
 832           * @param on_error callback to handle on error
 833           */
 834
 835          void WSF_CALL
 836         SimanSalomeServiceStub::start_putFile(org_splat_ws_server_service_salome::PutFile*  _putFile,
 837                                 ISimanSalomeServiceCallback* cb)
 838          {
 839
 840             axis2_callback_t *callback = NULL;
 841
 842             axis2_svc_client_t *svc_client = NULL;
 843             axis2_options_t *options = NULL;
 844
 845             const axis2_char_t *soap_action = NULL;
 846             axiom_node_t *payload = NULL;
 847
 848             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
 849             axutil_string_t *soap_act = NULL;
 850
 851
 852
 853             struct axis2_stub_SimanSalomeService_putFile_callback_data *callback_data;
 854
 855             callback_data = (struct axis2_stub_SimanSalomeService_putFile_callback_data*) AXIS2_MALLOC(Environment::getEnv()->allocator,
 856                                     sizeof(struct axis2_stub_SimanSalomeService_putFile_callback_data));
 857             if(NULL == callback_data)
 858             {
 859                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
 860                 AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "Can not allocate memory for the callback data structures");
 861                 return;
 862             }
 863
 864
 865
 866                                 payload = _putFile->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
 867
 868
 869             svc_client =   serviceClient->getAxis2SvcClient();
 870
 871
 872
 873
 874
 875             options = clientOptions->getAxis2Options();
 876             if (NULL == options)
 877             {
 878               AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
 879               AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
 880               return;
 881             }
 882
 883             soap_act =axis2_options_get_soap_action (options, Environment::getEnv());
 884             if (NULL == soap_act)
 885             {
 886               is_soap_act_set = AXIS2_FALSE;
 887               soap_action = "urn:putFile";
 888               soap_act = axutil_string_create(Environment::getEnv(), "urn:putFile");
 889               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
 890             }
 891
 892             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
 893
 894
 895             callback = axis2_callback_create(Environment::getEnv());
 896             /* Set our on_complete function pointer to the callback object */
 897             axis2_callback_set_on_complete(callback, axis2_stub_on_complete_SimanSalomeService_putFile);
 898             /* Set our on_error function pointer to the callback object */
 899             axis2_callback_set_on_error(callback, axis2_stub_on_error_SimanSalomeService_putFile);
 900
 901             callback_data->callback = cb;
 902             axis2_callback_set_data(callback, (void*)callback_data);
 903
 904             /* Send request */
 905             axis2_svc_client_send_receive_non_blocking(svc_client, Environment::getEnv(), payload, callback);
 906
 907             if (!is_soap_act_set)
 908             {
 909
 910               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
 911
 912               axis2_options_set_action(options, Environment::getEnv(), NULL);
 913             }
 914          }
 915
 916
 917
 918         struct axis2_stub_SimanSalomeService_checkIn_callback_data
 919         {
 920             ISimanSalomeServiceCallback *callback;
 921
 922         };
 923
 924         static axis2_status_t WSF_CALL axis2_stub_on_error_SimanSalomeService_checkIn(axis2_callback_t *axis_callback, const axutil_env_t *env, int exception)
 925         {
 926             struct axis2_stub_SimanSalomeService_checkIn_callback_data* callback_data = NULL;
 927             callback_data = (struct axis2_stub_SimanSalomeService_checkIn_callback_data*)axis2_callback_get_data(axis_callback);
 928
 929             ISimanSalomeServiceCallback* callback = NULL;
 930             callback = callback_data->callback;
 931             callback->receiveError_checkIn(exception);
 932             return AXIS2_SUCCESS;
 933         }
 934
 935         axis2_status_t  AXIS2_CALL axis2_stub_on_complete_SimanSalomeService_checkIn(axis2_callback_t *axis_callback, const axutil_env_t *env)
 936         {
 937             struct axis2_stub_SimanSalomeService_checkIn_callback_data* callback_data = NULL;
 938             axis2_status_t status = AXIS2_SUCCESS;
 939             org_splat_ws_server_service_salome::CheckInResponse* ret_val;
 940
 941
 942             axiom_node_t *ret_node = NULL;
 943             axiom_soap_envelope_t *soap_envelope = NULL;
 944
 945
 946
 947             ISimanSalomeServiceCallback *callback = NULL;
 948
 949             callback_data = (struct axis2_stub_SimanSalomeService_checkIn_callback_data*)axis2_callback_get_data(axis_callback);
 950
 951             callback = callback_data->callback;
 952
 953             soap_envelope = axis2_callback_get_envelope(axis_callback, Environment::getEnv());
 954             if(soap_envelope)
 955             {
 956                 axiom_soap_body_t *soap_body;
 957                 soap_body = axiom_soap_envelope_get_body(soap_envelope, Environment::getEnv());
 958                 if(soap_body)
 959                 {
 960                     axiom_soap_fault_t *soap_fault = NULL;
 961                     axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, Environment::getEnv());
 962
 963                       if(body_node)
 964                     {
 965                         ret_node = axiom_node_get_first_child(body_node, Environment::getEnv());
 966                     }
 967                 }
 968
 969
 970             }
 971
 972
 973
 974                     if(ret_node != NULL)
 975                     {
 976                         ret_val = new org_splat_ws_server_service_salome::CheckInResponse();
 977
 978                         if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
 979                         {
 980                             WSF_LOG_ERROR_MSG( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the LendResponse_deserialize: "
 981                                                                     "This should be due to an invalid XML");
 982                             delete ret_val;
 983                             ret_val = NULL;
 984                         }
 985                      }
 986                      else
 987                      {
 988                          ret_val = NULL;
 989                      }
 990
 991
 992                      callback->receiveResult_checkIn(ret_val);
 993
 994
 995             if(callback_data)
 996             {
 997                 AXIS2_FREE(Environment::getEnv()->allocator, callback_data);
 998             }
 999             return AXIS2_SUCCESS;
1000         }
1001
1002         /**
1003           * auto generated method signature for asynchronous invocations
1004           * for "checkIn|http://salome.service.ws_server.splat.org" operation.
1005           * @param stub The stub
1006           * @param env environment ( mandatory)
1007           * @param _checkIn of the org_splat_ws_server_service_salome::CheckIn
1008           * @param user_data user data to be accessed by the callbacks
1009           * @param on_complete callback to handle on complete
1010           * @param on_error callback to handle on error
1011           */
1012
1013          void WSF_CALL
1014         SimanSalomeServiceStub::start_checkIn(org_splat_ws_server_service_salome::CheckIn*  _checkIn,
1015                                 ISimanSalomeServiceCallback* cb)
1016          {
1017
1018             axis2_callback_t *callback = NULL;
1019
1020             axis2_svc_client_t *svc_client = NULL;
1021             axis2_options_t *options = NULL;
1022
1023             const axis2_char_t *soap_action = NULL;
1024             axiom_node_t *payload = NULL;
1025
1026             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1027             axutil_string_t *soap_act = NULL;
1028
1029
1030
1031             struct axis2_stub_SimanSalomeService_checkIn_callback_data *callback_data;
1032
1033             callback_data = (struct axis2_stub_SimanSalomeService_checkIn_callback_data*) AXIS2_MALLOC(Environment::getEnv()->allocator,
1034                                     sizeof(struct axis2_stub_SimanSalomeService_checkIn_callback_data));
1035             if(NULL == callback_data)
1036             {
1037                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
1038                 AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "Can not allocate memory for the callback data structures");
1039                 return;
1040             }
1041
1042
1043
1044                                 payload = _checkIn->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
1045
1046
1047             svc_client =   serviceClient->getAxis2SvcClient();
1048
1049
1050
1051
1052
1053             options = clientOptions->getAxis2Options();
1054             if (NULL == options)
1055             {
1056               AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1057               AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
1058               return;
1059             }
1060
1061             soap_act =axis2_options_get_soap_action (options, Environment::getEnv());
1062             if (NULL == soap_act)
1063             {
1064               is_soap_act_set = AXIS2_FALSE;
1065               soap_action = "urn:checkIn";
1066               soap_act = axutil_string_create(Environment::getEnv(), "urn:checkIn");
1067               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
1068             }
1069
1070             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
1071
1072
1073             callback = axis2_callback_create(Environment::getEnv());
1074             /* Set our on_complete function pointer to the callback object */
1075             axis2_callback_set_on_complete(callback, axis2_stub_on_complete_SimanSalomeService_checkIn);
1076             /* Set our on_error function pointer to the callback object */
1077             axis2_callback_set_on_error(callback, axis2_stub_on_error_SimanSalomeService_checkIn);
1078
1079             callback_data->callback = cb;
1080             axis2_callback_set_data(callback, (void*)callback_data);
1081
1082             /* Send request */
1083             axis2_svc_client_send_receive_non_blocking(svc_client, Environment::getEnv(), payload, callback);
1084
1085             if (!is_soap_act_set)
1086             {
1087
1088               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
1089
1090               axis2_options_set_action(options, Environment::getEnv(), NULL);
1091             }
1092          }
1093
1094
1095
1096         struct axis2_stub_SimanSalomeService_getFile_callback_data
1097         {
1098             ISimanSalomeServiceCallback *callback;
1099
1100         };
1101
1102         static axis2_status_t WSF_CALL axis2_stub_on_error_SimanSalomeService_getFile(axis2_callback_t *axis_callback, const axutil_env_t *env, int exception)
1103         {
1104             struct axis2_stub_SimanSalomeService_getFile_callback_data* callback_data = NULL;
1105             callback_data = (struct axis2_stub_SimanSalomeService_getFile_callback_data*)axis2_callback_get_data(axis_callback);
1106
1107             ISimanSalomeServiceCallback* callback = NULL;
1108             callback = callback_data->callback;
1109             callback->receiveError_getFile(exception);
1110             return AXIS2_SUCCESS;
1111         }
1112
1113         axis2_status_t  AXIS2_CALL axis2_stub_on_complete_SimanSalomeService_getFile(axis2_callback_t *axis_callback, const axutil_env_t *env)
1114         {
1115             struct axis2_stub_SimanSalomeService_getFile_callback_data* callback_data = NULL;
1116             axis2_status_t status = AXIS2_SUCCESS;
1117             org_splat_ws_server_service_salome::GetFileResponse* ret_val;
1118
1119
1120             axiom_node_t *ret_node = NULL;
1121             axiom_soap_envelope_t *soap_envelope = NULL;
1122
1123
1124
1125             ISimanSalomeServiceCallback *callback = NULL;
1126
1127             callback_data = (struct axis2_stub_SimanSalomeService_getFile_callback_data*)axis2_callback_get_data(axis_callback);
1128
1129             callback = callback_data->callback;
1130
1131             soap_envelope = axis2_callback_get_envelope(axis_callback, Environment::getEnv());
1132             if(soap_envelope)
1133             {
1134                 axiom_soap_body_t *soap_body;
1135                 soap_body = axiom_soap_envelope_get_body(soap_envelope, Environment::getEnv());
1136                 if(soap_body)
1137                 {
1138                     axiom_soap_fault_t *soap_fault = NULL;
1139                     axiom_node_t *body_node = axiom_soap_body_get_base_node(soap_body, Environment::getEnv());
1140
1141                       if(body_node)
1142                     {
1143                         ret_node = axiom_node_get_first_child(body_node, Environment::getEnv());
1144                     }
1145                 }
1146
1147
1148             }
1149
1150
1151
1152                     if(ret_node != NULL)
1153                     {
1154                         ret_val = new org_splat_ws_server_service_salome::GetFileResponse();
1155
1156                         if(ret_val->deserialize(&ret_node, NULL, AXIS2_FALSE ) == AXIS2_FAILURE)
1157                         {
1158                             WSF_LOG_ERROR_MSG( Environment::getEnv()->log, AXIS2_LOG_SI, "NULL returned from the LendResponse_deserialize: "
1159                                                                     "This should be due to an invalid XML");
1160                             delete ret_val;
1161                             ret_val = NULL;
1162                         }
1163                      }
1164                      else
1165                      {
1166                          ret_val = NULL;
1167                      }
1168
1169
1170                      callback->receiveResult_getFile(ret_val);
1171
1172
1173             if(callback_data)
1174             {
1175                 AXIS2_FREE(Environment::getEnv()->allocator, callback_data);
1176             }
1177             return AXIS2_SUCCESS;
1178         }
1179
1180         /**
1181           * auto generated method signature for asynchronous invocations
1182           * for "getFile|http://salome.service.ws_server.splat.org" operation.
1183           * @param stub The stub
1184           * @param env environment ( mandatory)
1185           * @param _getFile of the org_splat_ws_server_service_salome::GetFile
1186           * @param user_data user data to be accessed by the callbacks
1187           * @param on_complete callback to handle on complete
1188           * @param on_error callback to handle on error
1189           */
1190
1191          void WSF_CALL
1192         SimanSalomeServiceStub::start_getFile(org_splat_ws_server_service_salome::GetFile*  _getFile,
1193                                 ISimanSalomeServiceCallback* cb)
1194          {
1195
1196             axis2_callback_t *callback = NULL;
1197
1198             axis2_svc_client_t *svc_client = NULL;
1199             axis2_options_t *options = NULL;
1200
1201             const axis2_char_t *soap_action = NULL;
1202             axiom_node_t *payload = NULL;
1203
1204             axis2_bool_t is_soap_act_set = AXIS2_TRUE;
1205             axutil_string_t *soap_act = NULL;
1206
1207
1208
1209             struct axis2_stub_SimanSalomeService_getFile_callback_data *callback_data;
1210
1211             callback_data = (struct axis2_stub_SimanSalomeService_getFile_callback_data*) AXIS2_MALLOC(Environment::getEnv()->allocator,
1212                                     sizeof(struct axis2_stub_SimanSalomeService_getFile_callback_data));
1213             if(NULL == callback_data)
1214             {
1215                 AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
1216                 AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "Can not allocate memory for the callback data structures");
1217                 return;
1218             }
1219
1220
1221
1222                                 payload = _getFile->serialize(NULL, NULL, AXIS2_TRUE, NULL, NULL);
1223
1224
1225             svc_client =   serviceClient->getAxis2SvcClient();
1226
1227
1228
1229
1230
1231             options = clientOptions->getAxis2Options();
1232             if (NULL == options)
1233             {
1234               AXIS2_ERROR_SET(Environment::getEnv()->error, AXIS2_ERROR_INVALID_NULL_PARAM, AXIS2_FAILURE);
1235               AXIS2_LOG_ERROR( Environment::getEnv()->log, AXIS2_LOG_SI, "options is null in stub");
1236               return;
1237             }
1238
1239             soap_act =axis2_options_get_soap_action (options, Environment::getEnv());
1240             if (NULL == soap_act)
1241             {
1242               is_soap_act_set = AXIS2_FALSE;
1243               soap_action = "urn:getFile";
1244               soap_act = axutil_string_create(Environment::getEnv(), "urn:getFile");
1245               axis2_options_set_soap_action(options, Environment::getEnv(), soap_act);
1246             }
1247
1248             axis2_options_set_soap_version(options, Environment::getEnv(), AXIOM_SOAP12);
1249
1250
1251             callback = axis2_callback_create(Environment::getEnv());
1252             /* Set our on_complete function pointer to the callback object */
1253             axis2_callback_set_on_complete(callback, axis2_stub_on_complete_SimanSalomeService_getFile);
1254             /* Set our on_error function pointer to the callback object */
1255             axis2_callback_set_on_error(callback, axis2_stub_on_error_SimanSalomeService_getFile);
1256
1257             callback_data->callback = cb;
1258             axis2_callback_set_data(callback, (void*)callback_data);
1259
1260             /* Send request */
1261             axis2_svc_client_send_receive_non_blocking(svc_client, Environment::getEnv(), payload, callback);
1262
1263             if (!is_soap_act_set)
1264             {
1265
1266               axis2_options_set_soap_action(options, Environment::getEnv(), NULL);
1267
1268               axis2_options_set_action(options, Environment::getEnv(), NULL);
1269             }
1270          }
1271
1272
1273