WsdlInvoker.h

Go to the documentation of this file.

/* 
 * wsdlpull - A C++ parser  for WSDL  (Web services description language)
 * Copyright (C) 2005-2007 Vivek Krishna
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

//An api to examine and invoke the web service in a protocol independent fashion

#ifndef _WSDLINVOKERH
#define _WSDLINVOKERH

#include <xmlpull/XmlSerializer.h>
#include <wsdlparser/WsdlParser.h>
#include <wsdlparser/Soap.h>

 struct Parameter
 {
   Parameter(Schema::Type ,std::string,int m,int x,const SchemaParser* s);
   Schema::Type type_;
   std::string tag_;
   unsigned int min_;
   unsigned int max_;
   int n_;
   std::vector<std::string> data_;
   bool str_;
   const SchemaParser* sParser_;
 };

class WsdlInvoker 
{
 public:
  WsdlInvoker(const std::string &url);
  WsdlInvoker();
  ~WsdlInvoker();

  bool setWSDLUri(const std::string &url);
  int getOperations(std::vector<std::string> & operations);
  std::string getOpDocumentaion(const std::string & n);
  bool setOperation(const std::string & operation);

  
  bool setValue(const std::string & param,void* val);
  bool setValue(const std::string & param,void** values,unsigned int occur);
  bool setValue(const std::string & param,std::string val);
  bool setValue(const std::string & param,std::vector<std::string> values);//multiple occurrences
  bool invoke();
  void* getValue(const std::string & param,Schema::Type & t); 
  
  
  
  int getNextInput(std::string & param ,Schema::Type & type,int & min,int & max);
  
  bool setInputValue(const int param,void* val);
  bool setInputValue(const int id,void** values,unsigned int occur);

  bool setInputValue(const int param,std::string val);
  bool setInputValue(const int param,std::vector<std::string> values);//multiple occurrences
  bool getNextOutput(std::string  & name,TypeContainer * & tc);
  TypeContainer* getOutput(const std::string  & name);

  
  //enable logging
  void setVerbose(bool f);
  
  //get the error message
  std::string errors();
  //if this returns false something went wrong
  bool status()const;


 private:
  //private stuff 

  //creaate xml request
  void serialize();
  void serializeType(Schema::Type typeId,
                     const std::string &tag,
                     const SchemaParser * sParser,
                     int min,
                     int max);
  void serializeParam(int n,const std::string & tag,
                      const SchemaParser * sParser);
  void serializeContentModel(ContentModel *cm,
                             const SchemaParser *sParser);
  //creaate xml request
  void post();//make http post
  void processResults();
  void parseWsdl(const std::string & url);
  //reset state information
  void reset();

  WsdlParser * wParser_;
  XmlSerializer * xmlStream_;
  std::ostringstream * soapstr_;
  std::ostringstream logger_;
  bool status_;
  bool serializeMode_;
  bool verbose_;
  std::map<std::string,const Operation*> opMap_;
  const Operation* op_;
  Soap::Encoding use_;//literal or encoded
  Soap::Style style_;//rpc or doc
  std::string nsp_; // namespace for the operation
  std::string location_;
  std::string action_;//SOAPAction header
  std::vector<Parameter> elems_;//the simple types
  std::vector<Parameter> attribs_;//input attributes
  size_t n_;//a counter to iterate through the params
  std::vector<std::pair<std::string,TypeContainer*> > outputs_;
};

inline
Parameter::Parameter(Schema::Type t,std::string n,int m,int x,const SchemaParser* s)
  :type_(t),
     tag_(n),
     min_(m),
     max_(x),
     n_(0),
     sParser_(s)
     
{
}

inline
std::string 
WsdlInvoker::errors()
{
  return logger_.str();
}

inline
bool
WsdlInvoker::setWSDLUri(const std::string &url)
{
  parseWsdl(url);
  return status_;
}

inline
bool
WsdlInvoker::status()const
{
  return status_;
}

inline
void
WsdlInvoker::setVerbose(bool f)
{
  verbose_ = f;
}
#endif

---