#ifndef CPPCMS_URL_DISPATCHER_H

#define CPPCMS_URL_DISPATCHER_H

#include <booster/noncopyable.h>

#include <cppcms/defs.h>

#include <booster/function.h>

#include <booster/hold_ptr.h>

#include <booster/traits/enable_if.h>

#include <booster/traits/is_base_of.h>

#include <booster/traits/type_traits.h>

#include <booster/regex.h>

#include <cppcms/application.h>

#include <cppcms/steal_buf.h>

#include <string>

#include <list>

namespace cppcms {

///

/// Sets the content of parameter to output

///

/// \ver{v1_2}

inline bool parse_url_parameter(util::const_char_istream &parameter,std::string &output)

}

///

/// Parses general value

///

/// \ver{v1_2}

template<typename ParamType>

bool parse_url_parameter(util::const_char_istream &parameter,ParamType &value)

}

///

/// \brief This class is used to glue between member function of application class and urls

///

/// This class is used in context of \a cppcms::application with its \a url member function.

/// It uses regular expression to bind between url and callbacks that actually process the

/// request. It also allows mount sub-applications to the root of

/// the primary application.

///

/// There are two families of functions, assign and map.

/// Older `assign` interface allows matching only URL against regular expression.

/// and passes std::string as parameter. All the validation must be

/// performed by regular expression or the code that was called.

///

/// Newer `map` interface allows both matching an URL and an HTTP request method.

/// Parameters are parsed using `bool parse_url_parameter(util::const_char_istream &parameter,Type &param)`

/// that by default uses std::istream to perform casting.

///

/// Additionally every matched parameter is checked to contain valid text encoding

///

/// Newer API uses map member functions family that was introduced in CppCMS 1.1.

///

/// For example:

///

/// \code

/// class my_web_project : public cppcms::application {

/// users_app users_;

/// /* Older Handlers */

/// void display_page(std::string)

/// ...

/// /* Newer CppCMS 1.1 handlers */

/// void get_resource(int id);

/// void update_resource(int id);

/// void new_resource();

/// void id_by_name(std::string const &name); /* name checked for valid encoding */

/// void display_page_by_id(int id)

/// public:

/// my_web_project() {

/// /* Older API */

/// dispatcher().assign("/page/(\\d+)/?",&my_web_project::display_page,this,1);

///

/// /* New API - CppCMS 1.1 and above */

///

/// dispatcher().map("GET","/resource/(\\d+)",&my_web_project::get_resource,this,1);

/// dispatcher().map("PUT","/resource/(\\d+)",&my_web_project::update_resource,this,1);

/// dispatcher().map("POST","/resources",&my_web_project::new_resource,this);

/// dispatcher().map("GET"."/id_by_name/(.*)",&my_web_project::id_by_name,this,1);

/// dispatcher().map("/page/(\\d+)",&my_web_project::display_page_by_id,this,1); /* any method */

/// ...

/// \endcode

///

///

class CPPCMS_API url_dispatcher : public booster::noncopyable {

public:

///

/// \brief RESTful API Handler that validates parameters and executes a method.

///

/// If validation fails it should return false and thus the matching would continue to next handler

///

/// \ver{v1_2}

typedef booster::function<bool(cppcms::application &,booster::cmatch const &)> generic_handler;

// Handlers

typedef booster::function<void()> handler;

typedef booster::function<void(booster::cmatch const &)> rhandler;

typedef booster::function<void(std::string)> handler1;

typedef booster::function<void(std::string,std::string)> handler2;

typedef booster::function<void(std::string,std::string,std::string)> handler3;

typedef booster::function<void(std::string,std::string,std::string,std::string)> handler4;

typedef booster::function<void(std::string,std::string,std::string,std::string,std::string)> handler5;

typedef booster::function<void(std::string,std::string,std::string,std::string,std::string,std::string)> handler6;

///

/// Map a callback \a h to a URL matching regular expression \a re and an HTTP \a method

///

/// \param method - HTTP method to match like GET, POST, note regular expression can be used as well, for example "(POST|PUT)"

/// \param re - regular expression to match the URL

/// \param h - handler to execute

///

/// \ver{v1_2}

void map_generic(std::string const &method,booster::regex const &re,generic_handler const &h);

///

/// Map a callback \a h to a URL matching regular expression \a re

///

/// \param re - regular expression to match the URL

/// \param h - handler to execute

///

/// \ver{v1_2}

void map_generic(booster::regex const &re,generic_handler const &h);

#ifdef CPPCMS_DOXYGEN_DOCS

///

/// \brief Map \a member of \a app as a URL handler that matches regualr expression \a re and HTTP method \a method

///

/// \param method - HTTP method to match like GET, POST, note regular expression can be used as well, for example "(POST|PUT)"

/// \param re - regular expression to match the URL

/// \param member - member function of application \a app

/// \param app - application that its \a member is called

/// \param groups - matched groups converted to ApplicationMemberArgs

///

/// Note:

///

/// - number of integers in \a groups should match the number of arguments of \a member

/// - \a member can have up to 8 arguments MemberArgs and the function should receive same number of integer parameters representing matched groups

///

/// For exaample

/// \code

/// class foo : public cppcms::application {

/// ...

/// void page(int x,std::string const &name);

/// void update(int x);

/// foo(...)

/// {

/// dispatcher().map("GET","/page/(\\d+)(/(.*))?",&foo::page,this,1,3);

/// dispatcher().map("POST","/update/(\\d+)",&foo::update,this,1);

/// }

/// \endcode

///

/// When the reuqest matches the \a method and regualr expression \a re, \a member of \a app is called, For case of `page` that has two

/// parameters the first matched group is converted to integer and passed to as first parameter and 3rd group is passed as string to 2nd parameter

///

/// In case of `update` - that has only 1 parameter, a single integer should be passed

///

/// In addition to calling \a member function it calls app->init() before call

/// and app->clean() after the call if Application is derived from cppcms::application

///

///

/// \ver{v1_2}

template<typename Application,typename... ApplicationMemberArgs>

void map(std::string const &method,std::string const &re,void (Application::*member)(ApplicationMemberArgs...),Application *app, int ... groups );

///

/// \brief Map \a member of \a app as a URL handler that matches regualr expression \a re

///

/// \param re - regular expression to match the URL

/// \param member - member function of application \a app

/// \param app - application that its \a member is called

/// \param groups - matched groups converted to ApplicationMemberArgs

///

/// Note:

///

/// - number of integers in \a groups should match the number of arguments of \a member

/// - \a member can have up to 8 arguments MemberArgs and the function should receive same number of integer parameters representing matched groups

///

/// For exaample

/// \code

/// class foo : public cppcms::application {

/// ...

/// void page(int x,std::string const &name);

/// void update(int x);

/// foo(...)

/// {

/// dispatcher().map("/page/(\\d+)(/(.*))?",&foo::page,this,1,3);

/// dispatcher().map("/update/(\\d+)",&foo::update,this,1);

/// }

/// \endcode

///

/// When the reuqest URL the regualr expression \a re, \a member of \a app is called, For case of `page` that has two

/// parameters the first matched group is converted to integer and passed to as first parameter and 3rd group is passed as string to 2nd parameter

///

/// In case of `update` - that has only 1 parameter, a single integer should be passed

///

/// In addition to calling \a member function it calls app->init() before call

/// and app->clean() after the call if Application is derived from cppcms::application

///

///

/// \ver{v1_2}

template<typename Application,typename... ApplicationMemberArgs>

void map(std::string const &re,void (Application::*member)(ApplicationMemberArgs...),Application *app, int ... groups );

///

/// \brief Map \a member of \a app as a URL handler that matches regualr expression \a re and HTTP method \a method

///

/// \param method - HTTP method to match like GET, POST, note regular expression can be used as well, for example "(POST|PUT)"

/// \param re - regular expression to match the URL

/// \param member - member function of application \a app

/// \param app - application that its \a member is called

/// \param groups - matched groups converted to ApplicationMemberArgs

///

/// Note:

///

/// - number of integers in \a groups should match the number of arguments of \a member

/// - \a member can have up to 8 arguments MemberArgs and the function should receive same number of integer parameters representing matched groups

///

/// For exaample

/// \code

/// class foo : public cppcms::application {

/// ...

/// void page(int x,std::string const &name);

/// void update(int x);

/// foo(...)

/// {

/// using booster::regex;

/// dispatcher().map(regex("/page/(\\d+)(/(.*))?",regex::icase),&foo::page,this,1,3);

/// dispatcher().map("POST","/update/(\\d+)",&foo::update,this,1);

/// }

/// \endcode

///

/// When the reuqest matches the \a method and regualr expression \a re, \a member of \a app is called, For case of `page` that has two

/// parameters the first matched group is converted to integer and passed to as first parameter and 3rd group is passed as string to 2nd parameter

///

/// In case of `update` - that has only 1 parameter, a single integer should be passed

///

/// In addition to calling \a member function it calls app->init() before call

/// and app->clean() after the call if Application is derived from cppcms::application

///

///

/// \ver{v1_2}

template<typename Application,typename... ApplicationMemberArgs>

void map(std::string const &method,booster::regex const &re,void (Application::*member)(ApplicationMemberArgs...),Application *app, int ... groups );

///

/// \brief Map \a member of \a app as a URL handler that matches regualr expression \a re

///

/// \param re - regular expression to match the URL

/// \param member - member function of application \a app

/// \param app - application that its \a member is called

/// \param groups - matched groups converted to ApplicationMemberArgs

///

/// Note:

///

/// - number of integers in \a groups should match the number of arguments of \a member

/// - \a member can have up to 8 arguments MemberArgs and the function should receive same number of integer parameters representing matched groups

///

/// For exaample

/// \code

/// class foo : public cppcms::application {

/// ...

/// void page(int x,std::string const &name);

/// void update(int x);

/// foo(...)

/// {

/// using booster::regex;

/// dispatcher().map(regex("/page/(\\d+)(/(.*))?",regex::icase),&foo::page,this,1,3);

/// dispatcher().map("/update/(\\d+)",&foo::update,this,1);

/// }

/// \endcode

///

/// When the reuqest URL the regualr expression \a re, \a member of \a app is called, For case of `page` that has two

/// parameters the first matched group is converted to integer and passed to as first parameter and 3rd group is passed as string to 2nd parameter

///

/// In case of `update` - that has only 1 parameter, a single integer should be passed

///

/// In addition to calling \a member function it calls app->init() before call

/// and app->clean() after the call if Application is derived from cppcms::application

///

///

/// \ver{v1_2}

template<typename Application,typename... ApplicationMemberArgs>

void map(booster::regex const &re,void (Application::*member)(ApplicationMemberArgs...),Application *app, int ... groups );

#endif

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called with matched results

///

void assign_generic(std::string const &regex,rhandler handler);

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called

///

void assign(std::string const &regex,handler handler);

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called with first parameters

/// the string that was matched at position \a exp1.

///

/// For example: if

/// regular expression is "^/page/(\\d+)/(\\w+)$" , exp1=2, and the url is

/// "/page/13/to_be_or_not", then handler would be called with "to_be_or_not"

/// as its first parameter

///

void assign(std::string const &regex,handler1 handler,int exp1);

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called with 1st and 2nd parameters

/// the string that was matched at position \a exp1 and \a exp2

///

void assign(std::string const &regex,handler2 handler,int exp1,int exp2);

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called with 1st, 2nd and 3rd parameters

/// the string that was matched at position \a exp1, \a exp2 and \a exp2

///

void assign(std::string const &regex,handler3 handler,int exp1,int exp2,int exp3);

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called with 1st, 2nd, 3rd and 4th parameters

/// the string that was matched at position \a exp1, \a exp2, \a exp3 and \a exp4

///

void assign(std::string const &regex,handler4 handler,int exp1,int exp2,int exp3,int exp4);

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called with 1st, 2nd, 3rd, 4th and 5th parameters

/// the string that was matched at position \a exp1, \a exp2, \a exp3, \a exp4 and \a exp5

///

/// \ver{v1_2}

void assign(std::string const &regex,handler5 handler,int exp1,int exp2,int exp3,int exp4,int exp5);

///

/// Assign \a handler to pattern \a regex thus if URL that matches

/// this pattern requested, \a handler is called with 1st, 2nd, 3rd, 4th, 5th and 6th parameters

/// the string that was matched at position \a exp1, \a exp2, \a exp3, \a exp4, \a exp 5 and \a exp6

///

/// \ver{v1_2}

void assign(std::string const &regex,handler6 handler,int exp1,int exp2,int exp3,int exp4,int exp5,int exp6);

///

/// Try to find match between \a url and registered handlers and applications.

/// If the match was found, it returns the method, how handler should bd dispatched

/// synchronous or asynchronous, meaning the handler would be executed in thread pool

/// or in the main non-blocking loop

///

bool dispatch(std::string url);

/// \cond INTERNAL

url_dispatcher(application *app);

url_dispatcher();

~url_dispatcher();

/// \endcond

///

/// This template function is a shortcut to assign(regex,callback). It allows

/// assignment of \a member function of an \a object with signature void handler()

/// as simple as assign(expr,&bar::foo,this);

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

template<typename C>

void assign(std::string const &regex,void (C::*member)(),C *object)

{

assign(regex,binder0<C>(member,object));

}

///

/// This template function is a shortcut to assign_generic(regex,rhandler). It allows

/// assignment of \a member function of an \a object with signature void handler(booster::cmatch const &)

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

/// \ver{v1_2}

template<typename C>

void assign_generic(std::string const &regex,void (C::*member)(booster::cmatch const &),C *object)

{

assign_generic(regex,rbinder<C>(member,object));

}

///

/// This template function is a shortcut to assign(regex,callback,int). It allows

/// assignment of \a member function of an \a object with signature void handler(string)

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

template<typename C>

void assign(std::string const &regex,void (C::*member)(std::string),C *object,int e1)

{

assign(regex,binder1<C>(member,object),e1);

}

///

/// This template function is a shortcut to assign(regex,callback,int,int). It allows

/// assignment of \a member function of an \a object with signature void handler(string,string)

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

template<typename C>

void assign(std::string const &regex,void (C::*member)(std::string,std::string),C *object,int e1,int e2)

{

assign(regex,binder2<C>(member,object),e1,e2);

}

template<typename C>

///

/// This template function is a shortcut to assign(regex,callback,int,int,int). It allows

/// assignment of \a member function of an \a object with signature void handler(string,string,string)

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

void assign(std::string const &regex,void (C::*member)(std::string,std::string,std::string),C *object,int e1,int e2,int e3)

{

assign(regex,binder3<C>(member,object),e1,e2,e3);

}

///

/// This template function is a shortcut to assign(regex,callback,int,int,int,int). It allows

/// assignment of \a member function of an \a object with signature void handler(string,string,string,string)

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

template<typename C>

void assign(std::string const &regex,void (C::*member)(std::string,std::string,std::string,std::string),C *object,int e1,int e2,int e3,int e4)

{

assign(regex,binder4<C>(member,object),e1,e2,e3,e4);

}

///

/// This template function is a shortcut to assign(regex,callback,int,int,int,int,int). It allows

/// assignment of \a member function of an \a object with signature void handler(string,string,string,string,string)

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

/// \ver{v1_2}

template<typename C>

void assign(std::string const &regex,void (C::*member)(std::string,std::string,std::string,std::string,std::string),C *object,int e1,int e2,int e3,int e4,int e5)

{

assign(regex,binder5<C>(member,object),e1,e2,e3,e4,e5);

}

///

/// This template function is a shortcut to assign(regex,callback,int,int,int,int,int,int). It allows

/// assignment of \a member function of an \a object with signature void handler(string,string,string,string,string,string)

///

/// In addition to calling \a member function it calls object->init() before call

/// and object->clean() after the call of the C is derived from cppcms::application

///

/// \ver{v1_2}

template<typename C>

void assign(std::string const &regex,void (C::*member)(std::string,std::string,std::string,std::string,std::string,std::string),C *object,int e1,int e2,int e3,int e4,int e5,int e6)

{

assign(regex,binder6<C>(member,object),e1,e2,e3,e4,e5,e6);

}

///

/// Mount a sub application \a app to the URL dispatcher, using regular expression match.

///

/// When mounted the URL is checked against match expression and then calls app.main(substr) where

/// substr is the matched subexpression part. For example:

///

/// \code

/// dispatcher().mount("/formums((/.*)?)",forums,1);

/// \endcode

///

/// For example: for url /forums/page/3 it would call \c forums::main with value "/page/3"

///

void mount(std::string const &match,application &app,int part);

private:

template<typename C,typename Enable = void>

class page_guard {

public:

page_guard(C * /*o*/) {}

page_guard(C * /*o*/,std::istream &) {}

application *app() { return 0; }

};

template<typename C>

class page_guard<C,typename booster::enable_if<booster::is_base_of< cppcms::application,C> >::type > {

public:

page_guard(C *o) :

object_(o)

{

object_->init();

}

application *app() { return object_; }

~page_guard()

{

object_->clear();

}

private:

application *object_;

};

template<typename C>

struct binder0{

typedef void (C::*member_type)();

member_type member;

C *object;

binder0(member_type m,C *o) :

member(m),

object(o)

{

}

void operator()() const

{

page_guard<C> guard(object);

(object->*member)();

}

};

template<typename C>

struct rbinder{

};

template<typename C>

struct binder1{

};

template<typename C>

struct binder2{

};

template<typename C>

struct binder3{

};

template<typename C>

struct binder4{

};

template<typename C>

struct binder5{

};

static bool validate_encoding(application &app,char const *begin,char const *end);

static void setup_stream(application &app,std::istream &s);

template<typename C>

struct binder6{

};

template<typename T>

static bool parse(application &app,util::const_char_istream &p,booster::cmatch const &m,int group,T &v)

}

template<typename F>

struct url_binder;

#define CPPCMS_DEFANDPARSE(N) typename booster::remove_const_reference<P##N>::type p##N; \

if(!parse(app,s,m,g##N,p##N)) return false;

#define CPPCMS_DEFANDPARSE2(N1,N2) CPPCMS_DEFANDPARSE(N1) CPPCMS_DEFANDPARSE(N2)

#define CPPCMS_DEFANDPARSE3(N1,N2,N3) CPPCMS_DEFANDPARSE(N1) CPPCMS_DEFANDPARSE2(N2,N3)

#define CPPCMS_DEFANDPARSE4(N1,N2,N3,N4) CPPCMS_DEFANDPARSE2(N1,N2) CPPCMS_DEFANDPARSE2(N3,N4)

#define CPPCMS_DEFANDPARSE5(N1,N2,N3,N4,N5) CPPCMS_DEFANDPARSE2(N1,N2) CPPCMS_DEFANDPARSE3(N3,N4,N5)

#define CPPCMS_URLBINDER \

private: \

template<typename C CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_TPAR> \

struct url_binder<void (C::*)(CPPCMS_URLBINDER_MPAR)> { \

typedef void (C::*member_type)(CPPCMS_URLBINDER_MPAR); \

member_type member; C *self; \

CPPCMS_URLBINDER_GPAR \

url_binder( \

member_type m,C *s CPPCMS_URLBINDER_PRD \

CPPCMS_URLBINDER_IPAR \

) : member(m), \

self(s) CPPCMS_URLBINDER_PRD \

CPPCMS_URLBINDER_CPAR \

{} \

bool operator()(application &CPPCMS_URLBINDER_P1,booster::cmatch const &CPPCMS_URLBINDER_P2) { \

CPPCMS_URLBINDER_INIT CPPCMS_URLBINDER_PARSE \

page_guard<C> guard(self); \

(self->*member)(CPPCMS_URLBINDER_PPAR); \

return true; \

} \

}; \

public: \

template<typename C CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_TPAR> \

void map(std::string const &me,std::string const &re, \

void (C::*mb)(CPPCMS_URLBINDER_MPAR),C *app CPPCMS_URLBINDER_PRD \

CPPCMS_URLBINDER_IPAR) \

{ \

typedef url_binder<void(C::*)(CPPCMS_URLBINDER_MPAR)> btype; \

map_generic(me,re,btype(mb,app CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_PPAR)); \

} \

template<typename C CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_TPAR> \

void map(std::string const &re, \

void (C::*mb)(CPPCMS_URLBINDER_MPAR),C *app CPPCMS_URLBINDER_PRD \

CPPCMS_URLBINDER_IPAR) \

{ \

typedef url_binder<void (C::*)(CPPCMS_URLBINDER_MPAR)> btype; \

map_generic(re,btype(mb,app CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_PPAR)); \

} \

template<typename C CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_TPAR> \

void map(std::string const &me,booster::regex const &re, \

void (C::*mb)(CPPCMS_URLBINDER_MPAR),C *app CPPCMS_URLBINDER_PRD \

CPPCMS_URLBINDER_IPAR) \

{ \

typedef url_binder<void (C::*)(CPPCMS_URLBINDER_MPAR)> btype; \

map_generic(me,re,btype(mb,app CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_PPAR)); \

} \

template<typename C CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_TPAR> \

void map(booster::regex const &re, \

void (C::*mb)(CPPCMS_URLBINDER_MPAR),C *app CPPCMS_URLBINDER_PRD \

CPPCMS_URLBINDER_IPAR) \

{ \

typedef url_binder<void (C::*)(CPPCMS_URLBINDER_MPAR)> btype; \

map_generic(re,btype(mb,app CPPCMS_URLBINDER_PRD CPPCMS_URLBINDER_PPAR)); \

} \

private:

#define CPPCMS_URLBINDER_PRD

#define CPPCMS_URLBINDER_INIT

#define CPPCMS_URLBINDER_TPAR

#define CPPCMS_URLBINDER_MPAR

#define CPPCMS_URLBINDER_PPAR

#define CPPCMS_URLBINDER_GPAR

#define CPPCMS_URLBINDER_IPAR

#define CPPCMS_URLBINDER_CPAR

#define CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_P1

#define CPPCMS_URLBINDER_P2

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#undef CPPCMS_URLBINDER_INIT

#undef CPPCMS_URLBINDER_PRD

#undef CPPCMS_URLBINDER_P1

#undef CPPCMS_URLBINDER_P2

#define CPPCMS_URLBINDER_PRD ,

#define CPPCMS_URLBINDER_INIT util::const_char_istream s; setup_stream(app,s);

#define CPPCMS_URLBINDER_P1 app

#define CPPCMS_URLBINDER_P2 m

#define CPPCMS_URLBINDER_TPAR typename P1

#define CPPCMS_URLBINDER_MPAR P1

#define CPPCMS_URLBINDER_PPAR p1

#define CPPCMS_URLBINDER_GPAR int g1;

#define CPPCMS_URLBINDER_IPAR int p1

#define CPPCMS_URLBINDER_CPAR g1(p1)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE(1)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_TPAR typename P1,typename P2

#define CPPCMS_URLBINDER_MPAR P1,P2

#define CPPCMS_URLBINDER_PPAR p1,p2

#define CPPCMS_URLBINDER_GPAR int g1,g2;

#define CPPCMS_URLBINDER_IPAR int p1,int p2

#define CPPCMS_URLBINDER_CPAR g1(p1),g2(p2)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE2(1,2)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_TPAR typename P1,typename P2,typename P3

#define CPPCMS_URLBINDER_MPAR P1,P2,P3

#define CPPCMS_URLBINDER_PPAR p1,p2,p3

#define CPPCMS_URLBINDER_GPAR int g1,g2,g3;

#define CPPCMS_URLBINDER_IPAR int p1,int p2,int p3

#define CPPCMS_URLBINDER_CPAR g1(p1),g2(p2),g3(p3)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE3(1,2,3)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_TPAR typename P1,typename P2,typename P3,typename P4

#define CPPCMS_URLBINDER_MPAR P1,P2,P3,P4

#define CPPCMS_URLBINDER_PPAR p1,p2,p3,p4

#define CPPCMS_URLBINDER_GPAR int g1,g2,g3,g4;

#define CPPCMS_URLBINDER_IPAR int p1,int p2,int p3,int p4

#define CPPCMS_URLBINDER_CPAR g1(p1),g2(p2),g3(p3),g4(p4)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE4(1,2,3,4)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_TPAR typename P1,typename P2,typename P3,typename P4,typename P5

#define CPPCMS_URLBINDER_MPAR P1,P2,P3,P4,P5

#define CPPCMS_URLBINDER_PPAR p1,p2,p3,p4,p5

#define CPPCMS_URLBINDER_GPAR int g1,g2,g3,g4,g5;

#define CPPCMS_URLBINDER_IPAR int p1,int p2,int p3,int p4,int p5

#define CPPCMS_URLBINDER_CPAR g1(p1),g2(p2),g3(p3),g4(p4),g5(p5)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE5(1,2,3,4,5)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_TPAR typename P1,typename P2,typename P3,typename P4,typename P5,typename P6

#define CPPCMS_URLBINDER_MPAR P1,P2,P3,P4,P5,P6

#define CPPCMS_URLBINDER_PPAR p1,p2,p3,p4,p5,p6

#define CPPCMS_URLBINDER_GPAR int g1,g2,g3,g4,g5,g6;

#define CPPCMS_URLBINDER_IPAR int p1,int p2,int p3,int p4,int p5,int p6

#define CPPCMS_URLBINDER_CPAR g1(p1),g2(p2),g3(p3),g4(p4),g5(p5),g6(p6)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE5(1,2,3,4,5) CPPCMS_DEFANDPARSE(6)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_TPAR typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7

#define CPPCMS_URLBINDER_MPAR P1,P2,P3,P4,P5,P6,P7

#define CPPCMS_URLBINDER_PPAR p1,p2,p3,p4,p5,p6,p7

#define CPPCMS_URLBINDER_GPAR int g1,g2,g3,g4,g5,g6,g7;

#define CPPCMS_URLBINDER_IPAR int p1,int p2,int p3,int p4,int p5,int p6,int p7

#define CPPCMS_URLBINDER_CPAR g1(p1),g2(p2),g3(p3),g4(p4),g5(p5),g6(p6),g7(p7)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE5(1,2,3,4,5) CPPCMS_DEFANDPARSE2(6,7)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#define CPPCMS_URLBINDER_TPAR typename P1,typename P2,typename P3,typename P4,typename P5,typename P6,typename P7,typename P8

#define CPPCMS_URLBINDER_MPAR P1,P2,P3,P4,P5,P6,P7,P8

#define CPPCMS_URLBINDER_PPAR p1,p2,p3,p4,p5,p6,p7,p8

#define CPPCMS_URLBINDER_GPAR int g1,g2,g3,g4,g5,g6,g7,g8;

#define CPPCMS_URLBINDER_IPAR int p1,int p2,int p3,int p4,int p5,int p6,int p7,int p8

#define CPPCMS_URLBINDER_CPAR g1(p1),g2(p2),g3(p3),g4(p4),g5(p5),g6(p6),g7(p7),g8(p8)

#define CPPCMS_URLBINDER_PARSE CPPCMS_DEFANDPARSE5(1,2,3,4,5) CPPCMS_DEFANDPARSE3(6,7,8)

CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_TPAR

#undef CPPCMS_URLBINDER_MPAR

#undef CPPCMS_URLBINDER_PPAR

#undef CPPCMS_URLBINDER_GPAR

#undef CPPCMS_URLBINDER_IPAR

#undef CPPCMS_URLBINDER_CPAR

#undef CPPCMS_URLBINDER_PARSE

#undef CPPCMS_URLBINDER

#undef CPPCMS_URLBINDER_INIT

#undef CPPCMS_URLBINDER_PRD

#undef CPPCMS_URLBINDER_P1

#undef CPPCMS_URLBINDER_P2

struct _data;

booster::hold_ptr<_data> d;

};

} // cppcms

#endif