gvpe/src/callback.h

// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
// THIS IS A GENERATED FILE: distribution.

/*
 * callback.h -- C++ callback mechanism
 * Copyright (C) 2003-2008 Marc Lehmann <pcg@goof.com>
 *
 * This file is part of GVPE.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 * Additional permission under GNU GPL version 3 section 7
 *
 * If you modify this Program, or any covered work, by linking or
 * combining it with the OpenSSL project's OpenSSL library (or a modified
 * version of that library), containing parts covered by the terms of the
 * OpenSSL or SSLeay licenses, the licensors of this Program grant you
 * additional permission to convey the resulting work.  Corresponding
 * Source for a non-source form of such a combination shall include the
 * source code for the parts of OpenSSL used as well as that of the
 * covered work.
*/

#ifndef CALLBACK_H__
#define CALLBACK_H__

#define CALLBACK_H_VERSION 3

template<typename signature>
struct callback;

template<class R>
struct callback<R ()>
{
  typedef R (*ptr_type)(void *self);

  template<class K, R (K::*method)()>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call () const
  {
    return func (self);
  }

  R operator ()() const
  {
    return call ();
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)()>
  static R thunk (void *self)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) ();
  }
};

template<class R, class A1>
struct callback<R (A1)>
{
  typedef R (*ptr_type)(void *self, A1);

  template<class K, R (K::*method)(A1)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1) const
  {
    return func (self, a1);
  }

  R operator ()(A1 a1) const
  {
    return call (a1);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1)>
  static R thunk (void *self, A1 a1)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1);
  }
};

template<class R, class A1, class A2>
struct callback<R (A1, A2)>
{
  typedef R (*ptr_type)(void *self, A1, A2);

  template<class K, R (K::*method)(A1, A2)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2) const
  {
    return func (self, a1, a2);
  }

  R operator ()(A1 a1, A2 a2) const
  {
    return call (a1, a2);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2)>
  static R thunk (void *self, A1 a1, A2 a2)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2);
  }
};

template<class R, class A1, class A2, class A3>
struct callback<R (A1, A2, A3)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3);

  template<class K, R (K::*method)(A1, A2, A3)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3) const
  {
    return func (self, a1, a2, a3);
  }

  R operator ()(A1 a1, A2 a2, A3 a3) const
  {
    return call (a1, a2, a3);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3);
  }
};

template<class R, class A1, class A2, class A3, class A4>
struct callback<R (A1, A2, A3, A4)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3, A4);

  template<class K, R (K::*method)(A1, A2, A3, A4)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3, A4 a4) const
  {
    return func (self, a1, a2, a3, a4);
  }

  R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
  {
    return call (a1, a2, a3, a4);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3, A4)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3, a4);
  }
};

template<class R, class A1, class A2, class A3, class A4, class A5>
struct callback<R (A1, A2, A3, A4, A5)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5);

  template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
  {
    return func (self, a1, a2, a3, a4, a5);
  }

  R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
  {
    return call (a1, a2, a3, a4, a5);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3, a4, a5);
  }
};

template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
struct callback<R (A1, A2, A3, A4, A5, A6)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6);

  template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
  {
    return func (self, a1, a2, a3, a4, a5, a6);
  }

  R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
  {
    return call (a1, a2, a3, a4, a5, a6);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3, a4, a5, a6);
  }
};

template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7);

  template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
  {
    return func (self, a1, a2, a3, a4, a5, a6, a7);
  }

  R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
  {
    return call (a1, a2, a3, a4, a5, a6, a7);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);
  }
};

template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8);

  template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
  {
    return func (self, a1, a2, a3, a4, a5, a6, a7, a8);
  }

  R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
  {
    return call (a1, a2, a3, a4, a5, a6, a7, a8);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);
  }
};

template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9);

  template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
  {
    return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9);
  }

  R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
  {
    return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
  }
};

template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
{
  typedef R (*ptr_type)(void *self, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);

  template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
  {
    return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
  }

  R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
  {
    return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
  }

private:

  void *self;
  ptr_type func;

  template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
  static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
  }
};


#endif
Revision:	1.15
Committed:	Thu Aug 7 17:54:26 2008 UTC (15 years, 10 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-3_0, rel-2_2, rel-2_21, rel-2_22, rel-2_25
Changes since 1.14:	+28 -18 lines
Log Message:	update to gplv3, finally
#	User	Rev	Content
1	pcg	1.7	// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
2			// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
3			// THIS IS A GENERATED FILE: distribution.
4	pcg	1.2
5	pcg	1.1	/*
6	pcg	1.15	* callback.h -- C++ callback mechanism
7			* Copyright (C) 2003-2008 Marc Lehmann <pcg@goof.com>
8			*
9			* This file is part of GVPE.
10			*
11			* This program is free software; you can redistribute it and/or modify it
12			* under the terms of the GNU General Public License as published by the
13			* Free Software Foundation; either version 3 of the License, or (at your
14			* option) any later version.
15			*
16			* This program is distributed in the hope that it will be useful, but
17			* WITHOUT ANY WARRANTY; without even the implied warranty of
18			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
19			* Public License for more details.
20			*
21			* You should have received a copy of the GNU General Public License along
22			* with this program; if not, see <http://www.gnu.org/licenses/>.
23			*
24			* Additional permission under GNU GPL version 3 section 7
25			*
26			* If you modify this Program, or any covered work, by linking or
27			* combining it with the OpenSSL project's OpenSSL library (or a modified
28			* version of that library), containing parts covered by the terms of the
29			* OpenSSL or SSLeay licenses, the licensors of this Program grant you
30			* additional permission to convey the resulting work. Corresponding
31			* Source for a non-source form of such a combination shall include the
32			* source code for the parts of OpenSSL used as well as that of the
33			* covered work.
34	pcg	1.1	*/
35
36	pcg	1.4	#ifndef CALLBACK_H__
37			#define CALLBACK_H__
38	pcg	1.1
39	pcg	1.11	#define CALLBACK_H_VERSION 3
40	pcg	1.10
41	pcg	1.12	template<typename signature>
42			struct callback;
43	pcg	1.10
44	pcg	1.2	template<class R>
45	pcg	1.12	struct callback<R ()>
46	pcg	1.10	{
47	pcg	1.12	typedef R (ptr_type)(void self);
48	pcg	1.2
49	pcg	1.12	template<class K, R (K::*method)()>
50			void set (K *object)
51	pcg	1.11	{
52	pcg	1.12	self = object;
53			func = thunk<K, method>;
54	pcg	1.11	}
55
56	pcg	1.12	R call () const
57	pcg	1.11	{
58	pcg	1.12	return func (self);
59	pcg	1.11	}
60	pcg	1.2
61			R operator ()() const
62	pcg	1.11	{
63			return call ();
64			}
65	pcg	1.12
66			private:
67
68			void *self;
69			ptr_type func;
70	pcg	1.10
71	pcg	1.14	template<class klass, R (klass::*method)()>
72			static R thunk (void *self)
73	pcg	1.12	{
74			klass obj = static_cast<klass >(self);
75	pcg	1.14	return (obj->*method) ();
76	pcg	1.12	}
77	pcg	1.14	};
78
79			template<class R, class A1>
80			struct callback<R (A1)>
81			{
82			typedef R (ptr_type)(void self, A1);
83	pcg	1.1
84	pcg	1.12	template<class K, R (K::*method)(A1)>
85			void set (K *object)
86	pcg	1.11	{
87	pcg	1.12	self = object;
88			func = thunk<K, method>;
89	pcg	1.11	}
90
91	pcg	1.12	R call (A1 a1) const
92	pcg	1.11	{
93	pcg	1.12	return func (self, a1);
94	pcg	1.11	}
95	pcg	1.1
96	pcg	1.2	R operator ()(A1 a1) const
97	pcg	1.11	{
98			return call (a1);
99			}
100	pcg	1.12
101			private:
102
103			void *self;
104			ptr_type func;
105	pcg	1.10
106	pcg	1.14	template<class klass, R (klass::*method)(A1)>
107			static R thunk (void *self, A1 a1)
108	pcg	1.12	{
109			klass obj = static_cast<klass >(self);
110	pcg	1.14	return (obj->*method) (a1);
111	pcg	1.12	}
112	pcg	1.14	};
113
114			template<class R, class A1, class A2>
115			struct callback<R (A1, A2)>
116			{
117			typedef R (ptr_type)(void self, A1, A2);
118	pcg	1.2
119	pcg	1.12	template<class K, R (K::*method)(A1, A2)>
120			void set (K *object)
121	pcg	1.11	{
122	pcg	1.12	self = object;
123			func = thunk<K, method>;
124	pcg	1.11	}
125
126	pcg	1.12	R call (A1 a1, A2 a2) const
127	pcg	1.11	{
128	pcg	1.12	return func (self, a1, a2);
129	pcg	1.11	}
130	pcg	1.2
131			R operator ()(A1 a1, A2 a2) const
132	pcg	1.11	{
133			return call (a1, a2);
134			}
135	pcg	1.12
136			private:
137
138			void *self;
139			ptr_type func;
140	pcg	1.10
141	pcg	1.14	template<class klass, R (klass::*method)(A1, A2)>
142			static R thunk (void *self, A1 a1, A2 a2)
143	pcg	1.12	{
144			klass obj = static_cast<klass >(self);
145	pcg	1.14	return (obj->*method) (a1, a2);
146	pcg	1.12	}
147	pcg	1.14	};
148
149			template<class R, class A1, class A2, class A3>
150			struct callback<R (A1, A2, A3)>
151			{
152			typedef R (ptr_type)(void self, A1, A2, A3);
153	pcg	1.2
154	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3)>
155			void set (K *object)
156	pcg	1.11	{
157	pcg	1.12	self = object;
158			func = thunk<K, method>;
159	pcg	1.11	}
160
161	pcg	1.12	R call (A1 a1, A2 a2, A3 a3) const
162	pcg	1.11	{
163	pcg	1.12	return func (self, a1, a2, a3);
164	pcg	1.11	}
165	pcg	1.2
166			R operator ()(A1 a1, A2 a2, A3 a3) const
167	pcg	1.11	{
168			return call (a1, a2, a3);
169			}
170	pcg	1.12
171			private:
172	pcg	1.10
173	pcg	1.12	void *self;
174			ptr_type func;
175	pcg	1.10
176	pcg	1.14	template<class klass, R (klass::*method)(A1, A2, A3)>
177			static R thunk (void *self, A1 a1, A2 a2, A3 a3)
178	pcg	1.12	{
179			klass obj = static_cast<klass >(self);
180	pcg	1.14	return (obj->*method) (a1, a2, a3);
181	pcg	1.12	}
182	pcg	1.14	};
183
184			template<class R, class A1, class A2, class A3, class A4>
185			struct callback<R (A1, A2, A3, A4)>
186			{
187			typedef R (ptr_type)(void self, A1, A2, A3, A4);
188	pcg	1.2
189	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4)>
190			void set (K *object)
191	pcg	1.11	{
192	pcg	1.12	self = object;
193			func = thunk<K, method>;
194	pcg	1.11	}
195
196	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4) const
197	pcg	1.11	{
198	pcg	1.12	return func (self, a1, a2, a3, a4);
199	pcg	1.11	}
200	pcg	1.2
201			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
202	pcg	1.11	{
203			return call (a1, a2, a3, a4);
204			}
205	pcg	1.12
206			private:
207
208			void *self;
209			ptr_type func;
210	pcg	1.10
211	pcg	1.14	template<class klass, R (klass::*method)(A1, A2, A3, A4)>
212			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)
213	pcg	1.12	{
214			klass obj = static_cast<klass >(self);
215	pcg	1.14	return (obj->*method) (a1, a2, a3, a4);
216	pcg	1.12	}
217	pcg	1.14	};
218
219			template<class R, class A1, class A2, class A3, class A4, class A5>
220			struct callback<R (A1, A2, A3, A4, A5)>
221			{
222			typedef R (ptr_type)(void self, A1, A2, A3, A4, A5);
223	pcg	1.2
224	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
225			void set (K *object)
226	pcg	1.11	{
227	pcg	1.12	self = object;
228			func = thunk<K, method>;
229	pcg	1.11	}
230
231	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
232	pcg	1.11	{
233	pcg	1.12	return func (self, a1, a2, a3, a4, a5);
234	pcg	1.11	}
235	pcg	1.2
236			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
237	pcg	1.11	{
238			return call (a1, a2, a3, a4, a5);
239			}
240	pcg	1.12
241			private:
242
243			void *self;
244			ptr_type func;
245	pcg	1.10
246	pcg	1.14	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>
247			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
248	pcg	1.12	{
249			klass obj = static_cast<klass >(self);
250	pcg	1.14	return (obj->*method) (a1, a2, a3, a4, a5);
251	pcg	1.12	}
252	pcg	1.14	};
253
254			template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
255			struct callback<R (A1, A2, A3, A4, A5, A6)>
256			{
257			typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6);
258	pcg	1.2
259	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
260			void set (K *object)
261	pcg	1.11	{
262	pcg	1.12	self = object;
263			func = thunk<K, method>;
264	pcg	1.11	}
265
266	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
267	pcg	1.11	{
268	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6);
269	pcg	1.11	}
270	pcg	1.2
271			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
272	pcg	1.11	{
273			return call (a1, a2, a3, a4, a5, a6);
274			}
275	pcg	1.12
276			private:
277	pcg	1.10
278	pcg	1.12	void *self;
279			ptr_type func;
280	pcg	1.10
281	pcg	1.14	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>
282			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
283	pcg	1.12	{
284			klass obj = static_cast<klass >(self);
285	pcg	1.14	return (obj->*method) (a1, a2, a3, a4, a5, a6);
286	pcg	1.12	}
287	pcg	1.14	};
288
289			template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
290			struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
291			{
292			typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7);
293	pcg	1.2
294	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
295			void set (K *object)
296	pcg	1.11	{
297	pcg	1.12	self = object;
298			func = thunk<K, method>;
299	pcg	1.11	}
300
301	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
302	pcg	1.11	{
303	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7);
304	pcg	1.11	}
305	pcg	1.2
306			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
307	pcg	1.11	{
308			return call (a1, a2, a3, a4, a5, a6, a7);
309			}
310	pcg	1.12
311			private:
312
313			void *self;
314			ptr_type func;
315	pcg	1.10
316	pcg	1.14	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>
317			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
318	pcg	1.12	{
319			klass obj = static_cast<klass >(self);
320	pcg	1.14	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);
321	pcg	1.12	}
322	pcg	1.14	};
323
324			template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
325			struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>
326			{
327			typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8);
328	pcg	1.10
329	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
330			void set (K *object)
331	pcg	1.11	{
332	pcg	1.12	self = object;
333			func = thunk<K, method>;
334	pcg	1.11	}
335
336	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
337	pcg	1.11	{
338	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7, a8);
339	pcg	1.11	}
340	pcg	1.10
341			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
342	pcg	1.11	{
343			return call (a1, a2, a3, a4, a5, a6, a7, a8);
344			}
345	pcg	1.12
346			private:
347
348			void *self;
349			ptr_type func;
350	pcg	1.10
351	pcg	1.14	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
352			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
353	pcg	1.12	{
354			klass obj = static_cast<klass >(self);
355	pcg	1.14	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);
356	pcg	1.12	}
357	pcg	1.14	};
358
359			template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
360			struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
361			{
362			typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8, A9);
363	pcg	1.10
364	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
365			void set (K *object)
366	pcg	1.11	{
367	pcg	1.12	self = object;
368			func = thunk<K, method>;
369	pcg	1.11	}
370
371	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
372	pcg	1.11	{
373	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9);
374	pcg	1.11	}
375	pcg	1.10
376			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
377	pcg	1.11	{
378			return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
379			}
380	pcg	1.12
381			private:
382
383			void *self;
384			ptr_type func;
385	pcg	1.10
386	pcg	1.14	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
387			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
388	pcg	1.12	{
389			klass obj = static_cast<klass >(self);
390	pcg	1.14	return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
391	pcg	1.12	}
392	pcg	1.14	};
393
394			template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
395			struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
396			{
397			typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
398	pcg	1.10
399	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
400			void set (K *object)
401	pcg	1.11	{
402	pcg	1.12	self = object;
403			func = thunk<K, method>;
404	pcg	1.11	}
405
406	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
407	pcg	1.11	{
408	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
409	pcg	1.11	}
410	pcg	1.10
411			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
412	pcg	1.11	{
413			return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
414			}
415	pcg	1.14
416			private:
417
418			void *self;
419			ptr_type func;
420
421			template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
422			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
423			{
424			klass obj = static_cast<klass >(self);
425			return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
426			}
427	pcg	1.10	};
428
429
430	pcg	1.1	#endif