## Reference

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/config.hpp>

    SOAP_XML_HAS_EXPAT_SUPPORT
    SOAP_SERVER_HAS_PREFORK

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/dispatcher.hpp>

    namespace zeep {
      class dispatcher;
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/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 </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/exception.hpp>

    namespace zeep {
      class exception;
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/connection.hpp>

    namespace zeep {
      namespace http {
        class connection;
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/header.hpp>

    namespace zeep {
      namespace http {
        struct header;
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/md5.hpp>

    namespace zeep {
      namespace http {
        class md5;
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/message_parser.hpp>

    namespace zeep {
      namespace http {
        class parser;
        class reply_parser;
        class request_parser;
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/preforked-server.hpp>

    namespace zeep {
      namespace http {
        class preforked_server;
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/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,
                           method_not_allowed = =	405,
                           proxy_authentication_required = =	407,
                           internal_server_error = = 500,
                           not_implemented = =       501,
                           bad_gateway = =           502,
                           service_unavailable = =   503 };

        // Return the error string for the status_type.
        std::string get_status_text(status_type status);

        // Return the string describing the status_type in more detail.
        std::string get_status_description(status_type status);
        std::ostream & operator<<(std::ostream &, reply &);
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/request.hpp>

    namespace zeep {
      namespace http {
        struct request;
        std::iostream & operator<<(std::iostream & io, request & req);
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/request_handler.hpp>

    namespace zeep {
      namespace http {
        class request_handler;
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/http/webapp.hpp>

    namespace zeep {
      namespace http {
        class basic_webapp;
        class parameter_map;
        class parameter_value;

        struct unauthorized_exception;

        class webapp;

        typedef std::list< auth_info > auth_info_list;
        template<> std::string parameter_value::as<std::string >();
        namespace el {
        }
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/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 </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/server.hpp>

    namespace zeep {
      class server;
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/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 </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/xml/doctype.hpp>

    namespace zeep {
      namespace xml {
        namespace doctype {
          struct allowed_any;
          struct allowed_base;
          struct allowed_choice;
          struct allowed_element;
          struct allowed_empty;
          struct allowed_repeated;
          struct allowed_seq;

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

          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 </build/libzeep-8SPbhu/libzeep-3.0.5/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 </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/xml/node.hpp>

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

        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 </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/xml/parser.hpp>

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

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/xml/serialize.hpp>

    ZEEP_ELEMENT_NAME_VALUE(name)
    ZEEP_ATTRIBUTE_NAME_VALUE(name)
    SOAP_XML_SET_STRUCT_NAME(s)
    SOAP_XML_ADD_ENUM(e, v)

    namespace zeep {
      namespace xml {
        template<typename T> struct attribute_nvp;
        struct deserializer;
        template<typename T> struct element_nvp;
        struct schema_creator;
        struct serializer;
        template<typename T>
          element_nvp< T > make_element_nvp(const char * name, T & v);
        template<typename T>
          attribute_nvp< T > make_attribute_nvp(const char * name, T & v);
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/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 </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/xml/writer.hpp>

    namespace zeep {
      namespace xml {
        class writer;
      }
    }

### Header </build/libzeep-8SPbhu/libzeep-3.0.5/zeep/xml/xpath.hpp>

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