src/GetFile.cpp

   1
   2
   3         /**
   4          * GetFile.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 "GetFile.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 getFile|http://salome.service.ws_server.splat.org Element
  22                 */
  23            org_splat_ws_server_service_salome::GetFile::GetFile()
  24         {
  25
  26
  27             qname = NULL;
  28
  29                     property_Args0;
  30
  31             isValidArgs0  = false;
  32
  33                   qname =  axutil_qname_create (Environment::getEnv(),
  34                         "getFile",
  35                         "http://salome.service.ws_server.splat.org",
  36                         NULL);
  37
  38         }
  39
  40        org_splat_ws_server_service_salome::GetFile::GetFile(std::string arg_Args0)
  41         {
  42
  43                    qname = NULL;
  44
  45                  property_Args0;
  46
  47             isValidArgs0  = true;
  48
  49                  qname =  axutil_qname_create (Environment::getEnv(),
  50                        "getFile",
  51                        "http://salome.service.ws_server.splat.org",
  52                        NULL);
  53
  54                     property_Args0 = arg_Args0;
  55
  56         }
  57         org_splat_ws_server_service_salome::GetFile::~GetFile()
  58         {
  59
  60         }
  61
  62
  63
  64         bool WSF_CALL
  65         org_splat_ws_server_service_salome::GetFile::deserialize(axiom_node_t** dp_parent,bool *dp_is_early_node_valid, bool dont_care_minoccurs)
  66         {
  67           axiom_node_t *parent = *dp_parent;
  68
  69           bool status = AXIS2_SUCCESS;
  70
  71          const axis2_char_t* text_value = NULL;
  72          axutil_qname_t *mqname = NULL;
  73
  74             axutil_qname_t *element_qname = NULL;
  75
  76                axiom_node_t *first_node = NULL;
  77                bool is_early_node_valid = true;
  78                axiom_node_t *current_node = NULL;
  79                axiom_element_t *current_element = NULL;
  80
  81
  82               while(parent && axiom_node_get_node_type(parent, Environment::getEnv()) != AXIOM_ELEMENT)
  83               {
  84                   parent = axiom_node_get_next_sibling(parent, Environment::getEnv());
  85               }
  86               if (NULL == parent)
  87               {
  88                 return AXIS2_FAILURE;
  89               }
  90
  91
  92                     current_element = (axiom_element_t *)axiom_node_get_data_element(parent, Environment::getEnv());
  93                     mqname = axiom_element_get_qname(current_element, Environment::getEnv(), parent);
  94                     if (axutil_qname_equals(mqname, Environment::getEnv(), this->qname))
  95                     {
  96
  97                           first_node = axiom_node_get_first_child(parent, Environment::getEnv());
  98
  99                     }
 100                     else
 101                     {
 102                         WSF_LOG_ERROR_MSG(Environment::getEnv()->log, WSF_LOG_SI,
 103                               "Failed in building adb object for getFile : "
 104                               "Expected %s but returned %s",
 105                               axutil_qname_to_string(qname, Environment::getEnv()),
 106                               axutil_qname_to_string(mqname, Environment::getEnv()));
 107
 108                         return AXIS2_FAILURE;
 109                     }
 110
 111
 112
 113                      /*
 114                       * building args0 element
 115                       */
 116
 117
 118
 119                                    current_node = first_node;
 120                                    is_early_node_valid = false;
 121
 122
 123                                     while(current_node && axiom_node_get_node_type(current_node, Environment::getEnv()) != AXIOM_ELEMENT)
 124                                     {
 125                                         current_node = axiom_node_get_next_sibling(current_node, Environment::getEnv());
 126                                     }
 127                                     if(current_node != NULL)
 128                                     {
 129                                         current_element = (axiom_element_t *)axiom_node_get_data_element(current_node, Environment::getEnv());
 130                                         mqname = axiom_element_get_qname(current_element, Environment::getEnv(), current_node);
 131                                     }
 132
 133                                  element_qname = axutil_qname_create(Environment::getEnv(), "args0", "http://salome.service.ws_server.splat.org", NULL);
 134
 135
 136                            if (
 137                                 (current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname))))
 138                            {
 139                               if( current_node   && current_element && (axutil_qname_equals(element_qname, Environment::getEnv(), mqname)))
 140                               {
 141                                 is_early_node_valid = true;
 142                               }
 143
 144
 145                                       text_value = axiom_element_get_text(current_element, Environment::getEnv(), current_node);
 146                                       if(text_value != NULL)
 147                                       {
 148                                             status = setArgs0(text_value);
 149                                       }
 150
 151                                  if(AXIS2_FAILURE ==  status)
 152                                  {
 153                                      WSF_LOG_ERROR_MSG( Environment::getEnv()->log,WSF_LOG_SI,"failed in setting the value for args0 ");
 154                                      if(element_qname)
 155                                      {
 156                                          axutil_qname_free(element_qname, Environment::getEnv());
 157                                      }
 158                                      return AXIS2_FAILURE;
 159                                  }
 160                               }
 161
 162                   if(element_qname)
 163                   {
 164                      axutil_qname_free(element_qname, Environment::getEnv());
 165                      element_qname = NULL;
 166                   }
 167
 168           return status;
 169        }
 170
 171           bool WSF_CALL
 172           org_splat_ws_server_service_salome::GetFile::isParticle()
 173           {
 174
 175                  return false;
 176
 177           }
 178
 179
 180           void WSF_CALL
 181           org_splat_ws_server_service_salome::GetFile::declareParentNamespaces(
 182                     axiom_element_t *parent_element,
 183                     axutil_hash_t *namespaces, int *next_ns_index)
 184           {
 185
 186                   /* Here this is an empty function, Nothing to declare */
 187
 188           }
 189
 190
 191
 192         axiom_node_t* WSF_CALL
 193         org_splat_ws_server_service_salome::GetFile::serialize(axiom_node_t *parent,
 194                         axiom_element_t *parent_element,
 195                         int parent_tag_closed,
 196                         axutil_hash_t *namespaces,
 197                         int *next_ns_index)
 198         {
 199
 200
 201
 202          axiom_node_t *current_node = NULL;
 203          int tag_closed = 0;
 204
 205
 206
 207                 axiom_namespace_t *ns1 = NULL;
 208
 209                 axis2_char_t *qname_uri = NULL;
 210                 axis2_char_t *qname_prefix = NULL;
 211                 axis2_char_t *p_prefix = NULL;
 212
 213                     axis2_char_t *text_value_1;
 214                     axis2_char_t *text_value_1_temp;
 215
 216                axis2_char_t *start_input_str = NULL;
 217                axis2_char_t *end_input_str = NULL;
 218                unsigned int start_input_str_len = 0;
 219                unsigned int end_input_str_len = 0;
 220
 221
 222                axiom_data_source_t *data_source = NULL;
 223                axutil_stream_t *stream = NULL;
 224
 225
 226                 int next_ns_index_value = 0;
 227
 228                     namespaces = axutil_hash_make(Environment::getEnv());
 229                     next_ns_index = &next_ns_index_value;
 230
 231                            ns1 = axiom_namespace_create (Environment::getEnv(),
 232                                              "http://salome.service.ws_server.splat.org",
 233                                              "n");
 234                            axutil_hash_set(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING, axutil_strdup(Environment::getEnv(), "n"));
 235
 236
 237                     parent_element = axiom_element_create (Environment::getEnv(), NULL, "getFile", ns1 , &parent);
 238
 239
 240                     axiom_element_set_namespace(parent_element, Environment::getEnv(), ns1, parent);
 241
 242
 243
 244                     data_source = axiom_data_source_create(Environment::getEnv(), parent, &current_node);
 245                     stream = axiom_data_source_get_stream(data_source, Environment::getEnv());
 246
 247                        if(!(p_prefix = (axis2_char_t*)axutil_hash_get(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING)))
 248                        {
 249                            p_prefix = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof (axis2_char_t) * ADB_DEFAULT_NAMESPACE_PREFIX_LIMIT);
 250                            sprintf(p_prefix, "n%d", (*next_ns_index)++);
 251                            axutil_hash_set(namespaces, "http://salome.service.ws_server.splat.org", AXIS2_HASH_KEY_STRING, p_prefix);
 252
 253                            axiom_element_declare_namespace_assume_param_ownership(parent_element, Environment::getEnv(), axiom_namespace_create (Environment::getEnv(),
 254                                             "http://salome.service.ws_server.splat.org", p_prefix));
 255                        }
 256
 257
 258                    if (!isValidArgs0)
 259                    {
 260
 261                            /* no need to complain for minoccurs=0 element */
 262
 263
 264                    }
 265                    else
 266                    {
 267                      start_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 268                                  (4 + axutil_strlen(p_prefix) +
 269                                   axutil_strlen("args0")));
 270
 271                                  /* axutil_strlen("<:>") + 1 = 4 */
 272                      end_input_str = (axis2_char_t*)AXIS2_MALLOC(Environment::getEnv()->allocator, sizeof(axis2_char_t) *
 273                                  (5 + axutil_strlen(p_prefix) + axutil_strlen("args0")));
 274                                   /* axutil_strlen("</:>") + 1 = 5 */
 275
 276
 277
 278
 279
 280
 281                      /*
 282                       * parsing args0 element
 283                       */
 284
 285
 286
 287                             sprintf(start_input_str, "<%s%sargs0>",
 288                                  p_prefix?p_prefix:"",
 289                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 290
 291                         start_input_str_len = axutil_strlen(start_input_str);
 292                         sprintf(end_input_str, "</%s%sargs0>",
 293                                  p_prefix?p_prefix:"",
 294                                  (p_prefix && axutil_strcmp(p_prefix, ""))?":":"");
 295                         end_input_str_len = axutil_strlen(end_input_str);
 296
 297                            text_value_1 = (axis2_char_t*)property_Args0.c_str();
 298
 299                            axutil_stream_write(stream, Environment::getEnv(), start_input_str, start_input_str_len);
 300
 301
 302                            text_value_1_temp = axutil_xml_quote_string(Environment::getEnv(), text_value_1, true);
 303                            if (text_value_1_temp)
 304                            {
 305                                axutil_stream_write(stream, Environment::getEnv(), text_value_1_temp, axutil_strlen(text_value_1_temp));
 306                                AXIS2_FREE(Environment::getEnv()->allocator, text_value_1_temp);
 307                            }
 308                            else
 309                            {
 310                                axutil_stream_write(stream, Environment::getEnv(), text_value_1, axutil_strlen(text_value_1));
 311                            }
 312
 313                            axutil_stream_write(stream, Environment::getEnv(), end_input_str, end_input_str_len);
 314
 315
 316                      AXIS2_FREE(Environment::getEnv()->allocator,start_input_str);
 317                      AXIS2_FREE(Environment::getEnv()->allocator,end_input_str);
 318                  }
 319
 320
 321                    if(namespaces)
 322                    {
 323                        axutil_hash_index_t *hi;
 324                        void *val;
 325                        for (hi = axutil_hash_first(namespaces, Environment::getEnv()); hi; hi = axutil_hash_next(Environment::getEnv(), hi))
 326                        {
 327                            axutil_hash_this(hi, NULL, NULL, &val);
 328                            AXIS2_FREE(Environment::getEnv()->allocator, val);
 329                        }
 330                        axutil_hash_free(namespaces, Environment::getEnv());
 331                    }
 332
 333
 334             return parent;
 335         }
 336
 337
 338
 339
 340             /**
 341              * Getter for args0 by  Property Number 1
 342              */
 343             std::string WSF_CALL
 344             org_splat_ws_server_service_salome::GetFile::getProperty1()
 345             {
 346                 return getArgs0();
 347             }
 348
 349             /**
 350              * getter for args0.
 351              */
 352             std::string WSF_CALL
 353             org_splat_ws_server_service_salome::GetFile::getArgs0()
 354              {
 355                 return property_Args0;
 356              }
 357
 358             /**
 359              * setter for args0
 360              */
 361             bool WSF_CALL
 362             org_splat_ws_server_service_salome::GetFile::setArgs0(
 363                     const std::string  arg_Args0)
 364              {
 365
 366
 367                 if(isValidArgs0 &&
 368                         arg_Args0 == property_Args0)
 369                 {
 370
 371                     return true;
 372                 }
 373
 374
 375
 376
 377                 resetArgs0();
 378
 379
 380                         property_Args0 = std::string(arg_Args0.c_str());
 381                         isValidArgs0 = true;
 382
 383                 return true;
 384              }
 385
 386
 387
 388            /**
 389             * resetter for args0
 390             */
 391            bool WSF_CALL
 392            org_splat_ws_server_service_salome::GetFile::resetArgs0()
 393            {
 394                int i = 0;
 395                int count = 0;
 396
 397
 398
 399                isValidArgs0 = false;
 400                return true;
 401            }
 402
 403            /**
 404             * Check whether args0 is nill
 405             */
 406            bool WSF_CALL
 407            org_splat_ws_server_service_salome::GetFile::isArgs0Nil()
 408            {
 409                return !isValidArgs0;
 410            }
 411
 412            /**
 413             * Set args0 to nill (currently the same as reset)
 414             */
 415            bool WSF_CALL
 416            org_splat_ws_server_service_salome::GetFile::setArgs0Nil()
 417            {
 418                return resetArgs0();
 419            }
 420
 421
 422