![]() |
Generic configuration file, contains defines and (probably obsolete) stuff for msvc
HTTP_SERVER_HAS_PREFORK WEBAPP_USES_RESOURCES LIBZEEP_VERSION LIBZEEP_VERSION_MAJOR LIBZEEP_VERSION_MINOR LIBZEEP_VERSION_PATCH
This file contains an interface to the crypto related routines used throughout libzeep.
class invalid_base32; class invalid_base64; class invalid_hex; (, = ); (); (); (); (, = ); (); (); (); // return a string containing some random bytes (); // return the MD5 hash of data ( data); // return the SHA1 hash of data ( data); // return the SHA1 hash of data ( data); // return the SHA256 hash of data ( data); // return the HMAC using an MD5 hash of message signed with key ( message, key); // return the HMAC using an SHA1 hash of message signed with key ( message, key); // return the HMAC using an SHA256 hash of message signed with key ( message, key); (, , , ); (, , , ); }
definition of zeep::exception, base class for exceptions thrown by libzeep
class exception; }
definition of the zeep::http::connection class, that handles HTTP connections
class connection; } }
definition of the base class zeep::http::controller, used by e.g. rest_controller and soap_controller
class controller; } }
Source code specifically for Unix/Linux. Utility routines to build daemon processes
class daemon; } }
definition of the routines that can parse and interpret el (expression language) code in a web application context
template<typename OBJ> class expression_utility_object; class expression_utility_object_base; class scope; typedef ::zeep::json::element ; (scope &, ); (scope &, ); object (scope &, ); (scope &, ); (scope &, ); (scope &, ); object (scope &, ); } }
definition of the base class zeep::error_handler, the default creates very simple HTTP replies. Override to do something more fancy.
class error_handler; } }
definition of the zeep::controller class. This class takes care of handling requests that are mapped to call back functions and provides code to return XHTML formatted replies.
class html_controller; } }
definition of the zeep::login_controller class. This class inherits from html::controller and provides a default for /login and /logout handling.
class login_controller; } }
definition of the zeep::http::{request,reply}_parser classes that parse HTTP input/output
class parser; class reply_parser; class request_parser; } }
Code for a preforked http server implementation
class preforked_server; } }
definition of the zeep::http::reply class encapsulating a valid HTTP reply
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, see_other = = 303, 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. ( status); // Return the string describing the status_type in more detail. ( status); } }
definition of the zeep::http::request class encapsulating a valid HTTP request
struct file_param; template<typename T, typename > struct is_file_param_array_type; template<typename T> struct is_file_param_array_type<, , , , >; class request; is_file_param_array_type_v; } }
definition of the zeep::rest_controller class. Instances of this class take care of mapping member functions to REST calls automatically converting in- and output data
class rest_controller; } }
definition of various classes that help in handling HTTP authentication.
class invalid_password_exception; class password_encoder; class pbkdf2_sha256_password_encoder; class security_context; class simple_user_service; struct unauthorized_exception; struct user_details; class user_service; class user_unknown_exception; } }
definition of the zeep::http::server class
class basic_server; class server; } }
definition of the zeep::soap_controller class. Instances of this class take care of mapping member functions to SOAP calls automatically converting in- and output data
class soap_controller; class soap_envelope; xml::element (xml::element &&); xml::element (); xml::element (); } }
definition of the zeep::http::tag_processor classes. These classes take care of processing HTML templates
class tag_processor; class tag_processor_v1; class tag_processor_v2; } }
definition of the zeep::template_processor class. This class handles the loading and processing of XHTML files.
class basic_template_processor; class file_loader; template<typename Loader> class html_template_processor; class resource_loader; class rsrc_loader; typedef html_template_processor< file_loader > ; typedef html_template_processor< rsrc_loader > ; typedef file_based_html_template_processor ; // the actual definition of zeep::template_processor } }
A simple uri class. Uses a parser based on simple regular expressions
class uri; class uri_parse_error; (); (); (); } }
Code for zeep::json::element, the JSON object in libzeep
class element; template<> (); } }
forward declarations required for zeep::json::element, the JSON object in libzeep
factory classes for constructing zeep::json::element objects
various implementations of the from_element function that return the data contained in a zeep::json::element (JSON) object
generic iterator classes used by zeep::json::element
} } template<typename IteratorType> struct tuple_element<, ::>; template<typename IteratorType> struct tuple_element<, ::>; template<typename IteratorType> struct tuple_size<::>; }
definition of the serializer classes that help serialize data into and out of zeep::json::element (JSON) objects
template<typename E> struct deserializer; template<typename , typename > struct element_serializer; template<typename E> struct serializer; template<typename J, typename T> ( e, v); template<typename J, typename T> ( e, v); } }
various implementations of the to_element function that intializes a zeep::json::element object with some value
various templated classes that help selecting the right conversion routines when (de-)serializing zeep::json::element (JSON) objects
File containing the name_value_pair class.
ZEEP_SERIALIZATION_NVP(name)
template<typename T> class name_value_pair; template<typename T> name_value_pair< ( name, v); }
A simple std::streambuf implementation that wraps around const char* data.
class char_streambuf; }
definition of various classes that help classify data used to select the correct conversion routines
typedef ; struct nonesuch; typedef ; typedef ; typedef ; typedef ; is_detected_v; is_detected_exact_v; } } template<typename T, typename Archive, typename > struct has_serialize; template<typename T, typename Archive> struct has_serialize<, , >; template<typename T, typename > struct is_complete_type; template<typename T> struct is_complete_type<, >; template<typename T, typename S, typename > struct is_serializable_array_type; template<typename T, typename S> struct is_serializable_array_type<, , , , , >; template<typename T, typename S> struct is_serializable_type; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef ; typedef value_serializer< ; typedef ; is_complete_type_v; has_serialize_v; is_serializable_type_v; is_type_with_value_serializer_v; is_serializable_array_type_v; }
various definitions of data types and routines used to work with Unicode encoded text
enum encoding_type; typedef ; // utf-8 is not single byte e.g. ( enc); // Convert a string from UCS4 to UTF-8. ( s); (, ); // remove the last unicode character from an utf-8 string ( s); // return the first unicode and the advanced pointer from a string template<typename Iter> ( ptr, end); (, ); ( i); // A simple implementation of trim, removing white space from start and end of s. ( s); // Simplistic implementation of starts_with. ( s, p); // Simplistic implementation of ends_with. ( s, p); // Simplistic implementation of contains. ( s, p); // Simplistic implementation of split, with std:string in the vector. ( v, s, p, compress = ); // Simplistic to_lower function, works for one byte charsets only... ( s, loc = ); // Simplistic join function. template<typename Container> ( v, d); // Simplistic replace_all. ( s, p, r); }
File containing the common serialization code in libzeep.
Serialization in libzeep is used by both the XML and the JSON sub libraries. Code that is common is found here.
template<typename T, typename > struct value_serializer; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<typename T> struct value_serializer<, >; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; template<> struct value_serializer<>; }
routines for classifying characters in an XML context
// some character classification routines ( uc); ( uc); ( uc); ( uc); ( uc); ( s); ( uc); ( s); } }
various classes and definitions for handling and using XML DOCTYPE definitions
class attribute_; struct content_spec_any; struct content_spec_base; struct content_spec_choice; struct content_spec_element; struct content_spec_empty; struct content_spec_repeated; struct content_spec_seq; class element_; class entity; class general_entity; class parameter_entity; class validator; enum ContentSpecType { Empty, Any, Mixed, Children }; enum AttributeType { CDATA, ID, IDREF, IDREFS, ENTITY, ENTITIES, NMTOKEN, NMTOKENS, Notation, Enumerated }; enum AttributeDefault { None, Required, Implied, Fixed, Default }; typedef entity * > ; typedef element_ * > ; typedef attribute_ * > ; typedef content_spec_base * ; typedef content_spec_ptr > ; typedef ; } } }
definition of the zeep::xml::document class
struct doc_type; class document; document ( text, length); } } }
the core of the libzeep XML library defining the main classes in the DOM API
class attribute; class attribute_set; template<typename NodeType> class basic_node_list; class cdata; class comment; class element; struct format_info; template<typename NodeType, typename ContainerNodeType> class iterator_impl; class node; class node_list; class node_with_text; class processing_instruction; class text; typedef node * > ; typedef element * > ; (element &, element &, element &); } } template<> struct tuple_element<, ::>; template<> struct tuple_element<, ::>; template<> struct tuple_size<::>; }
The definition of the JSON parser in libzeep
( json, json::element & object); ( is, json::element & object); zeep::json::element ( s, len); } } }
definition of the libzeep XML parser, a recursive descent parser
class invalid_exception; class not_wf_exception; class parser; } }
definition of the serializer classes used to (de-)serialize XML data.
ZEEP_ELEMENT_NAME_VALUE(name) ZEEP_ATTRIBUTE_NAME_VALUE(name)
template<typename T> struct attribute_nvp; struct deserializer; template<typename T> struct element_nvp; template< N> struct priority_tag; template<> struct priority_tag<>; struct schema_creator; struct serializer; template<typename T, typename > struct type_serializer; template<typename T> struct type_serializer<>; template<typename T> struct type_serializer<, , >; template<typename T> struct type_serializer<, , >; template<typename T> struct type_serializer<, >; template<typename T, N> struct type_serializer<>; typedef element > ; template<typename T> element_nvp< ( name, v); template<typename T> attribute_nvp< ( name, v); } }
definition of the zeep::xml::xpath class, implementing a XPath 1.0 compatible search facility
class context; class xpath; } }