SOAP_XML_HAS_EXPAT_SUPPORT
SOAP_SERVER_HAS_PREFORK

namespace zeep {
  class dispatcher;
}

namespace zeep {
  class envelope;
  xml::element * make_envelope(xml::element *);
  xml::element * make_fault(const std::string &);
  xml::element * make_fault(const std::exception &);
}

namespace zeep {
  class exception;
}

namespace zeep {
  namespace http {
    class connection;
  }
}

namespace zeep {
  namespace http {
    struct header;
  }
}

namespace zeep {
  namespace http {
    class preforked_server_base;
    template<typename Server> class preforked_server;
  }
}

namespace zeep {
  namespace http {
    class reply;

    // Various predefined HTTP status codes. 
    enum status_type { cont =                   100, 
                       ok =                     200, 
                       created =                201, 
                       accepted =               202, 
                       no_content =             204, 
                       multiple_choices =       300, 
                       moved_permanently =      301, 
                       moved_temporarily =      302, 
                       not_modified =           304, 
                       bad_request =            400, 
                       unauthorized =           401, 
                       forbidden =              403, 
                       not_found =              404, 
                       internal_server_error =  500, 
                       not_implemented =        501, 
                       bad_gateway =            502, 
                       service_unavailable =    503 };
  }
}

namespace zeep {
  namespace http {
    struct request;
  }
}

namespace zeep {
  namespace http {
    class request_handler;
  }
}

namespace zeep {
  namespace http {
    class request_parser;
  }
}

namespace zeep {
  namespace http {
    struct unauthorized_exception;

    class parameter_value;
    class parameter_map;
    class webapp;
    template<> std::string parameter_value::as<std::string >();
    namespace el {
    }
  }
}

namespace zeep {
  namespace http {
    namespace el {
      class object;
      class scope;
      bool process_el(const scope &, std::string &);
      void evaluate_el(const scope &, const std::string &, object &);
      bool evaluate_el(const scope &, const std::string &);

      // for debugging purposes 
      std::ostream & operator<<(std::ostream & lhs, const scope & rhs);
    }
  }
}

namespace zeep {
  class server;
}

namespace zeep {
  namespace http {
    class server;
    std::string decode_url(const std::string &);
    std::string encode_url(const std::string &);
  }
}

namespace zeep {
  namespace xml {
    namespace doctype {
      class validator;

      struct allowed_base;
      struct allowed_any;
      struct allowed_empty;
      struct allowed_element;
      struct allowed_repeated;
      struct allowed_seq;
      struct allowed_choice;

      class attribute;
      class element;
      class entity;
      class general_entity;
      class parameter_entity;

      enum AttributeType { attTypeString, attTypeTokenizedID, 
                           attTypeTokenizedIDREF, attTypeTokenizedIDREFS, 
                           attTypeTokenizedENTITY, attTypeTokenizedENTITIES, 
                           attTypeTokenizedNMTOKEN, attTypeTokenizedNMTOKENS, 
                           attTypeNotation, attTypeEnumerated };

      enum AttributeDefault { attDefNone, attDefRequired, attDefImplied, 
                              attDefFixed, attDefDefault };

      typedef std::vector< entity * > entity_list;
      typedef std::vector< element * > element_list;
      typedef std::vector< attribute * > attribute_list;
      typedef allowed_base * allowed_ptr;
      typedef std::list< allowed_ptr > allowed_list;
      typedef state_base * state_ptr;
      std::ostream & operator<<(std::ostream & lhs, validator & rhs);
    }
  }
}

namespace zeep {
  namespace xml {
    class document;

    // Using operator>> is an alternative for calling rhs.read(lhs);. 
    std::istream & operator>>(std::istream & lhs, document & rhs);

    // Using operator<< is an alternative for calling writer w(lhs); rhs.write(w);. 
    std::ostream & operator<<(std::ostream & lhs, const document & rhs);

    // To read a document and process elements on the go, use this streaming input function. If the proc callback retuns false, processing is terminated. The doc_root parameter of the callback is the leading xml up to the first element. 
    void process_document_elements(std::istream & data, 
                                   const std::string & element_xpath, 
                                   boost::function< bool(node *doc_root, element *e)> cb);
  }
}

namespace zeep {
  namespace xml {
    class node;
    class container;
    class root_node;
    class comment;
    class processing_instruction;
    class text;
    class cdata;
    class attribute;
    class name_space;
    class element;

    typedef node * node_ptr;
    typedef std::list< node_ptr > node_set;
    typedef element * element_ptr;
    typedef std::list< element_ptr > element_set;
    typedef std::list< attribute * > attribute_set;
    typedef std::list< name_space * > name_space_list;

    // This is probably only useful for debugging purposes. 
    std::ostream & operator<<(std::ostream & lhs, const node & rhs);
    bool operator==(const node & lhs, const node & rhs);
  }
}

namespace zeep {
  namespace xml {
    class invalid_exception;
    class not_wf_exception;
    class parser;
  }
}

SOAP_XML_SET_STRUCT_NAME(s)
SOAP_XML_ADD_ENUM(e, v)

namespace zeep {
  namespace xml {
    struct serializer;
    struct deserializer;
    struct wsdl_creator;
  }
}

namespace zeep {
  namespace xml {

    // the supported encodings. Perhaps we should extend this list a bit? 
    enum encoding_type { enc_UTF8, enc_UTF16BE, enc_UTF16LE, enc_ISO88591 };
    typedef boost::uint32_t unicode;

    // some character classification routines 
    bool is_name_start_char(unicode uc);
    bool is_name_char(unicode uc);
    bool is_char(unicode uc);
    bool is_valid_system_literal_char(unicode uc);
    bool is_valid_system_literal(const std::string & s);
    bool is_valid_public_id_char(unicode uc);
    bool is_valid_public_id(const std::string & s);

    // Convert a string from UCS4 to UTF-8. 
    std::string wstring_to_string(const std::wstring & s);

    // manipulate UTF-8 encoded strings 
    void append(std::string & s, unicode ch);
    unicode pop_last_char(std::string & s);
  }
}

namespace zeep {
  namespace xml {
    class writer;
  }
}

namespace zeep {
  namespace xml {
    class context;
    class xpath;
  }
}