## Reference

### Header </home/maarten/projects/libzeep/zeep/config.hpp>

    SOAP_XML_HAS_EXPAT_SUPPORT
    SOAP_SERVER_HAS_PREFORK

### Header </home/maarten/projects/libzeep/zeep/dispatcher.hpp>

    namespace zeep {
      class dispatcher;
    }

### Header </home/maarten/projects/libzeep/zeep/envelope.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/exception.hpp>

    namespace zeep {
      class exception;
    }

### Header </home/maarten/projects/libzeep/zeep/http/connection.hpp>

    namespace zeep {
      namespace http {
        class connection;
      }
    }

### Header </home/maarten/projects/libzeep/zeep/http/header.hpp>

    namespace zeep {
      namespace http {
        struct header;
      }
    }

### Header </home/maarten/projects/libzeep/zeep/http/preforked-server.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/http/reply.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/http/request.hpp>

    namespace zeep {
      namespace http {
        struct request;
      }
    }

### Header </home/maarten/projects/libzeep/zeep/http/request_handler.hpp>

    namespace zeep {
      namespace http {
        class request_handler;
      }
    }

### Header </home/maarten/projects/libzeep/zeep/http/request_parser.hpp>

    namespace zeep {
      namespace http {
        class request_parser;
      }
    }

### Header </home/maarten/projects/libzeep/zeep/http/webapp.hpp>

    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 {
        }
      }
    }

### Header </home/maarten/projects/libzeep/zeep/http/webapp/el.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/server.hpp>

    namespace zeep {
      class server;
    }

### Header </home/maarten/projects/libzeep/zeep/http/server.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/xml/doctype.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/xml/document.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/xml/node.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/xml/parser.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/xml/serialize.hpp>

    SOAP_XML_SET_STRUCT_NAME(s)
    SOAP_XML_ADD_ENUM(e, v)

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

### Header </home/maarten/projects/libzeep/zeep/xml/unicode_support.hpp>

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

### Header </home/maarten/projects/libzeep/zeep/xml/writer.hpp>

    namespace zeep {
      namespace xml {
        class writer;
      }
    }

### Header </home/maarten/projects/libzeep/zeep/xml/xpath.hpp>

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