PrevUpHomeNext

Reference

Header </home/maarten/projects/libzeep/zeep/config.hpp>
Header </home/maarten/projects/libzeep/zeep/dispatcher.hpp>
Header </home/maarten/projects/libzeep/zeep/envelope.hpp>
Header </home/maarten/projects/libzeep/zeep/exception.hpp>
Header </home/maarten/projects/libzeep/zeep/http/connection.hpp>
Header </home/maarten/projects/libzeep/zeep/http/header.hpp>
Header </home/maarten/projects/libzeep/zeep/http/md5.hpp>
Header </home/maarten/projects/libzeep/zeep/http/message_parser.hpp>
Header </home/maarten/projects/libzeep/zeep/http/preforked-server.hpp>
Header </home/maarten/projects/libzeep/zeep/http/reply.hpp>
Header </home/maarten/projects/libzeep/zeep/http/request.hpp>
Header </home/maarten/projects/libzeep/zeep/http/request_handler.hpp>
Header </home/maarten/projects/libzeep/zeep/http/webapp.hpp>
Header </home/maarten/projects/libzeep/zeep/http/webapp/el.hpp>
Header </home/maarten/projects/libzeep/zeep/server.hpp>
Header </home/maarten/projects/libzeep/zeep/http/server.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/doctype.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/document.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/node.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/parser.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/serialize.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/unicode_support.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/writer.hpp>
Header </home/maarten/projects/libzeep/zeep/xml/xpath.hpp>

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 md5;
  }
}
namespace zeep {
  namespace http {
    class parser;
    class reply_parser;
    class request_parser;
  }
}
namespace zeep {
  namespace http {
    template<typename Server> class preforked_server;
    class preforked_server_base;
  }
}
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 &);
  }
}
namespace zeep {
  namespace http {
    struct request;
    std::iostream & operator<<(std::iostream & io, request & req);
  }
}
namespace zeep {
  namespace http {
    class request_handler;
  }
}
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 {
    }
  }
}
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 {
      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);
    }
  }
}
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 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);
  }
}
namespace zeep {
  namespace xml {
    class invalid_exception;
    class not_wf_exception;
    class parser;
  }
}

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

PrevUpHomeNext