# 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);
       (, , ,
                                   );
       (, , ,
                                     );
    }

### Header <zeep/exception.hpp>

definition of zeep::exception, base class for exceptions thrown by libzeep

      class exception;
    }

### Header <zeep/http/connection.hpp>

definition of the zeep::http::connection class, that handles HTTP connections

        class connection;
      }
    }

### Header <zeep/http/controller.hpp>

definition of the base class zeep::http::controller, used by e.g. rest_controller and soap_controller

        class controller;
      }
    }

### Header <zeep/http/daemon.hpp>

Source code specifically for Unix/Linux. Utility routines to build daemon processes

        class daemon;
      }
    }

### Header <zeep/http/el-processing.hpp>

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

### Header <zeep/http/error-handler.hpp>

definition of the base class zeep::error_handler, the default creates very simple HTTP replies. Override to do something more fancy.

        class error_handler;
      }
    }

### Header <zeep/http/header.hpp>

definition of the zeep::http::header class

        struct header;
      }
    }

### Header <zeep/http/html-controller.hpp>

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

### Header <zeep/http/login-controller.hpp>

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

### Header <zeep/http/message-parser.hpp>

definition of the zeep::http::{request,reply}_parser classes that parse HTTP input/output

        class parser;
        class reply_parser;
        class request_parser;
      }
    }

### Header <zeep/http/preforked-server.hpp>

Code for a preforked http server implementation

        class preforked_server;
      }
    }

### Header <zeep/http/reply.hpp>

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

### Header <zeep/http/request.hpp>

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

### Header <zeep/http/rest-controller.hpp>

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

### Header <zeep/http/security.hpp>

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

### Header <zeep/http/server.hpp>

definition of the zeep::http::server class

        class basic_server;
        class server;
      }
    }

### Header <zeep/http/soap-controller.hpp>

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

### Header <zeep/http/tag-processor.hpp>

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

### Header <zeep/http/template-processor.hpp>

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

### Header <zeep/http/uri.hpp>

A simple uri class. Uses a parser based on simple regular expressions

        class uri;
        class uri_parse_error;
         ();
         ();
         ();
      }
    }

### Header <zeep/json/element.hpp>

Code for zeep::json::element, the JSON object in libzeep

        class element;
        template<>  ();
      }
    }

### Header <zeep/json/element_fwd.hpp>

forward declarations required for zeep::json::element, the JSON object in libzeep

### Header <zeep/json/factory.hpp>

factory classes for constructing zeep::json::element objects

### Header <zeep/json/from_element.hpp>

various implementations of the from_element function that return the data contained in a zeep::json::element (JSON) object

### Header <zeep/json/iterator.hpp>

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

### Header <zeep/json/serializer.hpp>

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

### Header <zeep/json/to_element.hpp>

various implementations of the to_element function that intializes a zeep::json::element object with some value

### Header <zeep/json/type_traits.hpp>

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

### Header <zeep/streambuf.hpp>

A simple std::streambuf implementation that wraps around const char* data.

      class char_streambuf;
    }

### Header <zeep/type-traits.hpp>

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

### Header <zeep/unicode-support.hpp>

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

### Header <zeep/value-serializer.hpp>

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

### Header <zeep/xml/character-classification.hpp>

routines for classifying characters in an XML context

        // some character classification routines
         ( uc);
         ( uc);
         ( uc);
         ( uc);
         ( uc);
         ( s);
         ( uc);
         ( s);
      }
    }

### Header <zeep/xml/doctype.hpp>

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

### Header <zeep/xml/document.hpp>

definition of the zeep::xml::document class

        struct doc_type;

        class document;

          document ( text,  length);
        }
      }
    }

### Header <zeep/xml/node.hpp>

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

### Header <zeep/json/parser.hpp>

The definition of the JSON parser in libzeep

         ( json, json::element & object);
         ( is, json::element & object);

          zeep::json::element ( s,  len);
        }
      }
    }

### Header <zeep/xml/parser.hpp>

definition of the libzeep XML parser, a recursive descent parser

        class invalid_exception;
        class not_wf_exception;
        class parser;
      }
    }

### Header <zeep/xml/serialize.hpp>

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

### Header <zeep/xml/xpath.hpp>

definition of the zeep::xml::xpath class, implementing a XPath 1.0 compatible search facility

        class context;
        class xpath;
      }
    }