libzeep

PrevUpHomeNext

Reference


Reference

Header <zeep/config.hpp>

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

Header <zeep/crypto.hpp>

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::http::header class


  
    struct header;
  }
}

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

Header <zeep/nvp.hpp>

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

PrevUpHomeNext