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/XmlPullParser.h>
#include <xmlpull/XmlPullParserException.h>
#include <schemaparser/SchemaParser.h>
#include <wsdlparser/Wsdl.h>
#include <wsdlparser/PortType.h>
#include <wsdlparser/Message.h>
#include <wsdlparser/Operation.h>
#include <wsdlparser/Binding.h>
#include <wsdlparser/WsdlExtension.h>

const std::string wsdlUri="http://schemas.xmlsoap.org/wsdl/";
class Soap;
//Wsdl pull parser
class WsdlParser
{
 public:
  WsdlParser(istream & in = cin, ostream & out = cout);
  WsdlParser(const std::string& Uri,ostream & out = cout);
  ~WsdlParser();

  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
  string getNamespace(void);

  string getName();

  const string*  getDocumentation();

  const Binding *getBinding();

  const Binding *getBinding(Qname & q);

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

  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);

  list < const Message *>*getMessages();

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

  const SchemaParser *getSchemaParser(string targetNamespace) const;

  const SchemaParser *getSchemaParser(int schemaId) const;
  bool status()const;
  std::string wsdlPath()const;

  
  void addExtensibilityHandler(WsdlExtension * ext);
  WsdlExtension *  getExtensibilityHandler(const std::string & ns);
  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(ostream & out);
#endif

 private:
  /* 
   *  private methods for parsing
   */
  int peek(bool lookahead = true);
  int next();
  void error(string s,int level=0);
  string getNamespace(string prefix);
  Element * getElement(const Qname &);
  int getTypeId(const Qname &);
  int getSchema(const Qname & type);
  string* parseDoc();
  void parseDefinitions();
  void parseMessage();
  void parseAnnotation();
  void parseImport();
  PortType *parsePortType();
  Operation *parseOperation(PortType* p);
  void parseTypes();
  void parseBinding();
  void parseService();
  int handleExtensibilityAttributes(string prefix, 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_;
  std::list < const Message *> messages_list_;
  typedef struct
  {
    WsdlExtension *we;
    SchemaParser *spe;
  } ExtensionInfo;
  std::vector<ExtensionInfo> wsdlExtensions_;
  list < PortType *>porttypes_list_;
  list < Binding *>bindings_list_;

  class Imports
    {
    public:
      Imports(std::string,std::string);
      std::string ns, loc;
    };
  std::vector<Imports> imports_;
  list < string *> docs_list_;
  std::ostream & ostr;
  std::istream & istr;
  int state_;
  int element_;                            //the last Wsdl element parsed
  string* Doc_;
  XmlPullParser * xParser_;
  std::ifstream xmlStream;
  std::string wsdlFileName;
  Soap * soap_;
  const int MAX_EXT_XML;
};

inline
WsdlParser::Imports::Imports(std::string nameSpace,std::string location)
  :ns(nameSpace),
     loc(location)
{
}


inline
std::string
WsdlParser::getNamespace(string prefix)
{
  return xParser_->getNamespace(prefix);
}


//public  APIs
inline
int  
WsdlParser::getNextElement()
{
  next();
  return element_;
}

inline
const std::string*
WsdlParser::getDocumentation() 
{
  return  (const string*) Doc_;
}

inline
std::string
WsdlParser::getNamespace(void)
{
  return tnsUri_;
}

inline
std::string
WsdlParser::getName()
{
  return name_;
}



inline
int
WsdlParser::getEventType()
{
  return element_;
}


inline
list < const Message *>*
WsdlParser::getMessages()
{
  return &messages_list_;
}

inline
int
WsdlParser::getNumSchemas() const
{
  return schemaParser_.size()-1;
}

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_;
}
/*  */
#endif                                            /*  */

---