WsdlParser.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.
 *
 */
#ifndef _WSDLPARSERH
#define _WSDLPARSERH
 
#include "xmlpull/wsdlpull_export.h"
#include "xmlpull/XmlPullParser.h"
#include "xmlpull/XmlPullParserException.h"
#include "schemaparser/SchemaParser.h"
 
#include "wsdlparser/PortType.h"
#include "wsdlparser/Message.h"
#include "wsdlparser/Operation.h"
#include "wsdlparser/Binding.h"
#include "wsdlparser/Service.h"
#include "wsdlparser/WsdlExtension.h"
 
 
 
namespace WsdlPull{
 
  const std::string wsdlUri="http://schemas.xmlsoap.org/wsdl/";
 
class Soap;
//Wsdl pull parser
class WSDLPULL_EXPORT WsdlParser
{
 public:

  WsdlParser(std::istream & in = std::cin, std::ostream & out = std::cout,
             const std::string & schemaPath = "");
  WsdlParser(const std::string& Uri,std::ostream & out = std::cout,
             const std::string & schemaPath = "");
  ~WsdlParser();

  void setSchemaPath(const std::string & schemaPath);


  int getNextElement();

  int getEventType();


  //NOTE:The caller must *NOT* free the pointers returned by the getter apis
  //This is true for all apis except whenever the api returns a pointer to 
  //a list of elements which is not one  of the root wsdl elements ,
  //such as getOperations(port type) which is the only exception
  std::string getNamespace(void);

  std::string getName();

  const std::string*  getDocumentation();

  const Binding *getBinding();

  const Binding *getBinding(const Qname & q);

  bool  getBindings(Binding::cBindingIterator & begin,
                    Binding::cBindingIterator & end)const;

  const Service *getService();

    typedef std::list<Service*>::iterator ServiceIterator;
  const Service *getService(const Qname & q);
    void getServices(ServiceIterator &from, ServiceIterator &to);

  const PortType *getPortType();

  const PortType *getPortType(const Qname & q);

  bool getPortTypes(PortType::cPortTypeIterator& begin,
                    PortType::cPortTypeIterator& end)const;

  bool getOperations(const Qname & portType,
                     Operation::cOpIterator& begin,
                     Operation::cOpIterator& end);

  const Operation *getOperation(const Qname & portType, 
                                const Qname & q);

  const Message *getMessage();

  const Message *getMessage(const Qname & q);

  std::list < const Message *>& getMessages();

 
  void getSchemaParsers(std::vector<SchemaParser* >::iterator & from,
                        std::vector<SchemaParser* >::iterator & to) ;
  
  int getNumSchemas() const;

  const SchemaParser *getSchemaParser(std::string targetNamespace) const;
 

  bool status()const;
  std::string wsdlPath()const;
  std::ostream & logger();
  std::string &getWsdlFileName() {
    return wsdlFileName;
  }
  
  static bool useLocalSchema_;//if false fetch the schemas from the web
 
  

  void addExtensibilityHandler(WsdlExtension * ext);
  WsdlExtension *  getExtensibilityHandler(const std::string & ns);
   //return the extensibility handler for the given id.
   //WsdlParser only stores ids for the extensibility elements.
  WsdlExtension * getExtensibilityHandler(int extId);
 
 

  bool setFeature (int feature_id);
 

  enum
    {
      NONE ,
      START,
      DEFINITION,
      DOCUMENTATION,
      ANNOTATION,
      IMPORT,
      SCHEMA,
      TYPES,
      MESSAGE,
      PART,
      PORT_TYPE,
      OPERATION,
      INPUT,
      OUTPUT,
      FAULT,
      BINDING,
      EXTENSIBILITY,
      SERVICE,
      PORT,
      END
    };
 
#ifdef LOGGING
  //for debugging
  void print(std::ostream & out);
#endif
 
  //{@ Deprecated
  const SchemaParser *getSchemaParser(int schemaId) const;
 
 
 private:
  /* 
   *  private methods for parsing
   */
  int peek(bool lookahead = true);
  int next();
  void error(std::string s,int level=0);
  std::string getNamespace(std::string prefix);
  Element * getElement(const Qname &);
  int getTypeId(const Qname &);
    int getSchema(const Qname & name,bool type = true);
  std::string* parseDoc();
  void parseDefinitions();
  void parseMessage();
  void parseAnnotation();
  void parseImport();
  PortType *parsePortType();
  Operation *parseOperation(PortType* p);
  void processMessageExtensibility(Operation * op,
                                   WsdlPull::MessageType mtype);
  void parseTypes();
  void parseBinding();
  void parseService();
  int handleExtensibilityAttributes(std::string prefix, std::string name);
  int handleExtensibilityElement(int);
  void putMessage(Message * m);
  void putPortType(PortType * pt);
  void putBinding(Binding * bn);
  void initialize(bool);
  bool errorOccured_;
  XmlPullParser* openSchemaFile(const std::string& path);
  const Message *pgetMessage(const Qname& q);
  std::string name_, tnsPrefix_, tnsUri_;
  std::vector<SchemaParser*> schemaParser_;
 
  typedef struct
  {
    WsdlExtension *we;
    SchemaParser *spe;
  } ExtensionInfo;
  std::list < const Message *> messages_;
  std::vector<ExtensionInfo> wsdlExtensions_;
  std::list < PortType *>porttypes_;
  std::list < Binding *>bindings_;
  std::list < Service*> services_;
 
  class Imports
  {
  public:
    Imports(std::string,std::string);
    std::string ns, loc;
  };
  std::vector<Imports> imports_;
  std::list < std::string *> docs_list_;
  std::ostream & ostr;
  std::istream & istr;
  int state_;
  int element_;                            //the last Wsdl element parsed
  std::string* Doc_;
  XmlPullParser * xParser_;
  std::ifstream xmlStream;
  std::string wsdlFileName;
  Soap * soap_,*soap2_;
  const int MAX_EXT_XML;
  std::string schemaPath_; // Path to schemas, used by parser during parsing.
  std::string uri_; //The uri to use to resolve imports.1 level up the location of the wsdl file
};
 
 
inline
WsdlParser::Imports::Imports(std::string nameSpace,std::string location)
  :ns(nameSpace),
     loc(location)
{
}
 
 
inline
std::string
WsdlParser::getNamespace(std::string prefix)
{
  return xParser_->getNamespace(prefix);
}
 
 
//public  APIs
inline
int  
WsdlParser::getNextElement()
{
  next();
  return element_;
}
 
inline
const std::string*
WsdlParser::getDocumentation() 
{
  return  (const std::string*) Doc_;
}
 
inline
std::string
WsdlParser::getNamespace(void)
{
  return tnsUri_;
}
 
inline
std::string
WsdlParser::getName()
{
  return name_;
}
 
 
 
inline
int
WsdlParser::getEventType()
{
  return element_;
}
 
 
inline
std::list < const Message *>&
WsdlParser::getMessages()
{
  return messages_;
}
 
//This is deprecated
//the ids 0 and 1 are return the schema parsers used to internally parse the soap schema.
//Ideally you should use getSchemaParser(std::string).If you want to iterate over all the schema parsers
//use getSchemaParsers
inline
const SchemaParser *
WsdlParser::getSchemaParser(int schemaId) const
{
  return (const SchemaParser *) schemaParser_[schemaId];
}
 
inline
std::string
WsdlParser::wsdlPath()const
{
  return wsdlFileName           ;
}
inline
bool
WsdlParser::status()const
{
 return !errorOccured_;
}
 
inline
std::ostream&
WsdlParser::logger()
{
  return ostr;
}
}
/*  */
#endif                                            /*  */