SchemaParser.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 _SCHEMAPARSERH
#define _SCHEMAPARSERH

#include <map>
#include <xmlpull/XmlPullParser.h>
#include <schemaparser/Schema.h>
#include <schemaparser/SchemaParserException.h>
#include <schemaparser/Group.h>
#include <schemaparser/Element.h>
#include <schemaparser/Constraint.h>
#include <schemaparser/AttributeGroup.h>
#include <schemaparser/ComplexType.h>
#include <schemaparser/SimpleType.h>
#include <schemaparser/TypesTable.h>


//class Schema Parser
class SchemaParser
{
 public:

  SchemaParser(const string&  Uri, string tns = "", ostream & log = cout);

  SchemaParser(XmlPullParser * parser, string tns = "", ostream & log = cout);

  ~SchemaParser();


  bool parseSchemaTag();



  const XSDType *getType(const Qname & type) ;

  const XSDType *getType(int id) const;

  list < const XSDType *>*getAllTypes() const;

  const Element *getElement(const Qname & element) const;
  
  const list<Element> getElements() const;

  int getNumElements() const;

  Attribute *getAttribute(const Qname & attribute) ;

  const list<Attribute> getAttributes()const;
  
  int getNumAttributes() const;


  string getNamespace(void) const;

  int getNumTypes() const;


  int getTypeId(const Qname &, bool create = false);

  bool isBasicType(int sType) const;

  int getBasicContentType(int typeId)const;
  
  Group* getGroup(const Qname& name);
  
  AttributeGroup* getAttributeGroup(const Qname& name);
 

  bool addImports(const std::vector<SchemaParser *>& schemaParsers); //to be removed soon
  bool addImport(string ns, string location="");
  bool addImport(SchemaParser* sp);



  bool finalize(void);

  void setWarningLevel(unsigned char l);
#ifdef LOGGING

  void print(ostream &) ;
#endif


 private:
  //This function parses global elements
  Element  parseElement(bool & fwdRef);
  //This function parses global attributes
  Attribute parseAttribute(bool & fwdRef);

  //This  function parses <annotation> tag
  void parseAnnotation();
  ComplexType *parseComplexType();
  SimpleType *parseSimpleType();


  Element addAny(ContentModel* cm);
  Group parseGroup(ContentModel* cm=0);
  Constraint* parseConstraint(Schema::Constraints cstr);
  AttributeGroup parseAttributeGroup(ComplexType* cType=0);
  Attribute addAnyAttribute(ComplexType * cType);

  void parseRestriction(SimpleType * st,ComplexType * ct=0);
  void parseComplexContent(ComplexType * ct);
  void parseSimpleContent(ComplexType * ct);

  void parseContent(ContentModel * cm);
  bool parseImport(void);
  bool parseInclude();
  bool parseSchema(std::string tag="schema");
  bool parseRedefine();
  int checkImport(string nsp);
  void resolveForwardElementRefs();
  void resolveForwardAttributeRefs();
  int  addExternalElement(const string & name,int localTypeId);
  bool& shouldResolve();

  std::map<std::string,std::string>
    SchemaParser::processAttributes(XmlPullParser* xpp);

  std::string tnsUri_;
  std::string tnsPrefix_;
  XmlPullParser * xParser_;
  bool elementQualified_;
  bool attributeQualified_;
  bool deleteXmlParser_;
  bool resolveFwdRefs_;
  
  TypesTable typesTable_;
  std::ifstream xmlStream_;
  std::list<Element> lElems_;
  std::list<Attribute> lAttributes_;
  std::list<Group> lGroups_;
  std::list<AttributeGroup> lAttributeGroups_;
  std::list<Constraint*> constraints_;
  std::list<Qname> lForwardElemRefs_;
  std::list<Qname> lForwardAttributeRefs_;
  
  typedef struct
  {
    SchemaParser* sParser;
    std::string ns;
  } ImportedSchema ;
  std::vector<ImportedSchema> importedSchemas_;  
  void error(string, int level = 0);
  unsigned char level_;//warning level
  std::ostream & logFile_;
};


inline
bool &
SchemaParser::shouldResolve()
{
  return resolveFwdRefs_;
  
}

inline
const list<Element> 
SchemaParser::getElements() const
{
  return lElems_;
}

inline
const list<Attribute> 
SchemaParser::getAttributes() const
{
  return lAttributes_;
}
inline
void
SchemaParser::setWarningLevel(unsigned char l)
{
  level_ = l;
}

#endif                                            /*  */

---