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