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-2007 Marc Lehmann <pcg@goof.com>
 
    This file is part of GVPE.

    GVPE 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 2 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 gvpe; if not, write to the Free Software
    Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

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