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;

#define callback_set(callback,obj,klass,method) callback.set<klass, &klass::method> (obj)

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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

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

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

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

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


#endif
Revision:	1.12
Committed:	Tue Dec 4 15:01:12 2007 UTC (16 years, 5 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+312 -402 lines
Log Message:	switch to new cb system
#	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.12	#define callback_set(callback,obj,klass,method) callback.set<klass, &klass::method> (obj)
35	pcg	1.10
36	pcg	1.2	template<class R>
37	pcg	1.12	struct callback<R ()>
38	pcg	1.10	{
39	pcg	1.12	typedef R (ptr_type)(void self);
40	pcg	1.2
41	pcg	1.12	private:
42	pcg	1.10
43	pcg	1.12	void *self;
44			ptr_type func;
45
46			protected:
47
48			template<typename method>
49			struct thunktype;
50
51			template<class klass>
52			struct thunktype<R (klass::*)>
53			{
54			typedef klass K;
55			};
56
57			template<class klass, R (klass::*method)()>
58			static R thunk (void *self)
59			{
60			klass obj = static_cast<klass >(self);
61			return (obj->*method) ();
62			}
63	pcg	1.2
64			public:
65	pcg	1.12	template<class K, R (K::*method)()>
66			void set (K *object)
67	pcg	1.11	{
68	pcg	1.12	self = object;
69			func = thunk<K, method>;
70	pcg	1.11	}
71
72	pcg	1.12	R call () const
73	pcg	1.11	{
74	pcg	1.12	return func (self);
75	pcg	1.11	}
76	pcg	1.2
77			R operator ()() const
78	pcg	1.11	{
79			return call ();
80			}
81	pcg	1.2	};
82
83	pcg	1.12	template<class R, class A1>
84			struct callback<R (A1)>
85	pcg	1.10	{
86	pcg	1.12	typedef R (ptr_type)(void self, A1);
87
88			private:
89
90			void *self;
91			ptr_type func;
92	pcg	1.10
93	pcg	1.12	protected:
94	pcg	1.10
95	pcg	1.12	template<typename method>
96			struct thunktype;
97	pcg	1.1
98	pcg	1.12	template<class klass>
99			struct thunktype<R (klass::*)>
100			{
101			typedef klass K;
102			};
103	pcg	1.1
104	pcg	1.12	template<class klass, R (klass::*method)(A1)>
105			static R thunk (void *self, A1 a1)
106			{
107			klass obj = static_cast<klass >(self);
108			return (obj->*method) (a1);
109			}
110	pcg	1.1
111			public:
112	pcg	1.12	template<class K, R (K::*method)(A1)>
113			void set (K *object)
114	pcg	1.11	{
115	pcg	1.12	self = object;
116			func = thunk<K, method>;
117	pcg	1.11	}
118
119	pcg	1.12	R call (A1 a1) const
120	pcg	1.11	{
121	pcg	1.12	return func (self, a1);
122	pcg	1.11	}
123	pcg	1.1
124	pcg	1.2	R operator ()(A1 a1) const
125	pcg	1.11	{
126			return call (a1);
127			}
128	pcg	1.2	};
129
130	pcg	1.12	template<class R, class A1, class A2>
131			struct callback<R (A1, A2)>
132	pcg	1.10	{
133	pcg	1.12	typedef R (ptr_type)(void self, A1, A2);
134
135			private:
136
137			void *self;
138			ptr_type func;
139	pcg	1.10
140	pcg	1.12	protected:
141	pcg	1.10
142	pcg	1.12	template<typename method>
143			struct thunktype;
144	pcg	1.10
145	pcg	1.12	template<class klass>
146			struct thunktype<R (klass::*)>
147			{
148			typedef klass K;
149			};
150	pcg	1.2
151	pcg	1.12	template<class klass, R (klass::*method)(A1, A2)>
152			static R thunk (void *self, A1 a1, A2 a2)
153			{
154			klass obj = static_cast<klass >(self);
155			return (obj->*method) (a1, a2);
156			}
157	pcg	1.2
158			public:
159	pcg	1.12	template<class K, R (K::*method)(A1, A2)>
160			void set (K *object)
161	pcg	1.11	{
162	pcg	1.12	self = object;
163			func = thunk<K, method>;
164	pcg	1.11	}
165
166	pcg	1.12	R call (A1 a1, A2 a2) const
167	pcg	1.11	{
168	pcg	1.12	return func (self, a1, a2);
169	pcg	1.11	}
170	pcg	1.2
171			R operator ()(A1 a1, A2 a2) const
172	pcg	1.11	{
173			return call (a1, a2);
174			}
175	pcg	1.2	};
176
177	pcg	1.12	template<class R, class A1, class A2, class A3>
178			struct callback<R (A1, A2, A3)>
179	pcg	1.10	{
180	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3);
181
182			private:
183
184			void *self;
185			ptr_type func;
186	pcg	1.10
187	pcg	1.12	protected:
188	pcg	1.10
189	pcg	1.12	template<typename method>
190			struct thunktype;
191	pcg	1.2
192	pcg	1.12	template<class klass>
193			struct thunktype<R (klass::*)>
194			{
195			typedef klass K;
196			};
197	pcg	1.10
198	pcg	1.12	template<class klass, R (klass::*method)(A1, A2, A3)>
199			static R thunk (void *self, A1 a1, A2 a2, A3 a3)
200			{
201			klass obj = static_cast<klass >(self);
202			return (obj->*method) (a1, a2, a3);
203			}
204	pcg	1.2
205			public:
206	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3)>
207			void set (K *object)
208	pcg	1.11	{
209	pcg	1.12	self = object;
210			func = thunk<K, method>;
211	pcg	1.11	}
212
213	pcg	1.12	R call (A1 a1, A2 a2, A3 a3) const
214	pcg	1.11	{
215	pcg	1.12	return func (self, a1, a2, a3);
216	pcg	1.11	}
217	pcg	1.2
218			R operator ()(A1 a1, A2 a2, A3 a3) const
219	pcg	1.11	{
220			return call (a1, a2, a3);
221			}
222	pcg	1.2	};
223
224	pcg	1.12	template<class R, class A1, class A2, class A3, class A4>
225			struct callback<R (A1, A2, A3, A4)>
226	pcg	1.10	{
227	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3, A4);
228
229			private:
230	pcg	1.10
231	pcg	1.12	void *self;
232			ptr_type func;
233	pcg	1.10
234	pcg	1.12	protected:
235	pcg	1.10
236	pcg	1.12	template<typename method>
237			struct thunktype;
238	pcg	1.2
239	pcg	1.12	template<class klass>
240			struct thunktype<R (klass::*)>
241			{
242			typedef klass K;
243			};
244
245			template<class klass, R (klass::*method)(A1, A2, A3, A4)>
246			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4)
247			{
248			klass obj = static_cast<klass >(self);
249			return (obj->*method) (a1, a2, a3, a4);
250			}
251	pcg	1.2
252			public:
253	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4)>
254			void set (K *object)
255	pcg	1.11	{
256	pcg	1.12	self = object;
257			func = thunk<K, method>;
258	pcg	1.11	}
259
260	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4) const
261	pcg	1.11	{
262	pcg	1.12	return func (self, a1, a2, a3, a4);
263	pcg	1.11	}
264	pcg	1.2
265			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
266	pcg	1.11	{
267			return call (a1, a2, a3, a4);
268			}
269	pcg	1.2	};
270
271	pcg	1.12	template<class R, class A1, class A2, class A3, class A4, class A5>
272			struct callback<R (A1, A2, A3, A4, A5)>
273	pcg	1.10	{
274	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5);
275
276			private:
277
278			void *self;
279			ptr_type func;
280	pcg	1.10
281	pcg	1.12	protected:
282	pcg	1.10
283	pcg	1.12	template<typename method>
284			struct thunktype;
285	pcg	1.2
286	pcg	1.12	template<class klass>
287			struct thunktype<R (klass::*)>
288			{
289			typedef klass K;
290			};
291	pcg	1.2
292	pcg	1.12	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5)>
293			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
294			{
295			klass obj = static_cast<klass >(self);
296			return (obj->*method) (a1, a2, a3, a4, a5);
297			}
298	pcg	1.2
299			public:
300	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5)>
301			void set (K *object)
302	pcg	1.11	{
303	pcg	1.12	self = object;
304			func = thunk<K, method>;
305	pcg	1.11	}
306
307	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
308	pcg	1.11	{
309	pcg	1.12	return func (self, a1, a2, a3, a4, a5);
310	pcg	1.11	}
311	pcg	1.2
312			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
313	pcg	1.11	{
314			return call (a1, a2, a3, a4, a5);
315			}
316	pcg	1.2	};
317
318	pcg	1.12	template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
319			struct callback<R (A1, A2, A3, A4, A5, A6)>
320	pcg	1.10	{
321	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6);
322
323			private:
324
325			void *self;
326			ptr_type func;
327	pcg	1.10
328	pcg	1.12	protected:
329	pcg	1.10
330	pcg	1.12	template<typename method>
331			struct thunktype;
332	pcg	1.10
333	pcg	1.12	template<class klass>
334			struct thunktype<R (klass::*)>
335			{
336			typedef klass K;
337			};
338	pcg	1.2
339	pcg	1.12	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6)>
340			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
341			{
342			klass obj = static_cast<klass >(self);
343			return (obj->*method) (a1, a2, a3, a4, a5, a6);
344			}
345	pcg	1.2
346			public:
347	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6)>
348			void set (K *object)
349	pcg	1.11	{
350	pcg	1.12	self = object;
351			func = thunk<K, method>;
352	pcg	1.11	}
353
354	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
355	pcg	1.11	{
356	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6);
357	pcg	1.11	}
358	pcg	1.2
359			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
360	pcg	1.11	{
361			return call (a1, a2, a3, a4, a5, a6);
362			}
363	pcg	1.2	};
364
365	pcg	1.12	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
366			struct callback<R (A1, A2, A3, A4, A5, A6, A7)>
367	pcg	1.10	{
368	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7);
369
370			private:
371	pcg	1.10
372	pcg	1.12	void *self;
373			ptr_type func;
374	pcg	1.10
375	pcg	1.12	protected:
376	pcg	1.2
377	pcg	1.12	template<typename method>
378			struct thunktype;
379	pcg	1.10
380	pcg	1.12	template<class klass>
381			struct thunktype<R (klass::*)>
382			{
383			typedef klass K;
384			};
385
386			template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7)>
387			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
388			{
389			klass obj = static_cast<klass >(self);
390			return (obj->*method) (a1, a2, a3, a4, a5, a6, a7);
391			}
392	pcg	1.2
393			public:
394	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7)>
395			void set (K *object)
396	pcg	1.11	{
397	pcg	1.12	self = object;
398			func = thunk<K, method>;
399	pcg	1.11	}
400
401	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
402	pcg	1.11	{
403	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7);
404	pcg	1.11	}
405	pcg	1.2
406			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
407	pcg	1.11	{
408			return call (a1, a2, a3, a4, a5, a6, a7);
409			}
410	pcg	1.1	};
411
412	pcg	1.12	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
413			struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8)>
414	pcg	1.10	{
415	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8);
416
417			private:
418
419			void *self;
420			ptr_type func;
421	pcg	1.10
422	pcg	1.12	protected:
423	pcg	1.10
424	pcg	1.12	template<typename method>
425			struct thunktype;
426	pcg	1.10
427	pcg	1.12	template<class klass>
428			struct thunktype<R (klass::*)>
429			{
430			typedef klass K;
431			};
432	pcg	1.10
433	pcg	1.12	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
434			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
435			{
436			klass obj = static_cast<klass >(self);
437			return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8);
438			}
439	pcg	1.10
440			public:
441	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8)>
442			void set (K *object)
443	pcg	1.11	{
444	pcg	1.12	self = object;
445			func = thunk<K, method>;
446	pcg	1.11	}
447
448	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
449	pcg	1.11	{
450	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7, a8);
451	pcg	1.11	}
452	pcg	1.10
453			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
454	pcg	1.11	{
455			return call (a1, a2, a3, a4, a5, a6, a7, a8);
456			}
457	pcg	1.10	};
458
459	pcg	1.12	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
460			struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)>
461	pcg	1.10	{
462	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8, A9);
463
464			private:
465
466			void *self;
467			ptr_type func;
468	pcg	1.10
469	pcg	1.12	protected:
470	pcg	1.10
471	pcg	1.12	template<typename method>
472			struct thunktype;
473	pcg	1.10
474	pcg	1.12	template<class klass>
475			struct thunktype<R (klass::*)>
476			{
477			typedef klass K;
478			};
479	pcg	1.10
480	pcg	1.12	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
481			static R thunk (void *self, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
482			{
483			klass obj = static_cast<klass >(self);
484			return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9);
485			}
486	pcg	1.10
487			public:
488	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
489			void set (K *object)
490	pcg	1.11	{
491	pcg	1.12	self = object;
492			func = thunk<K, method>;
493	pcg	1.11	}
494
495	pcg	1.12	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
496	pcg	1.11	{
497	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9);
498	pcg	1.11	}
499	pcg	1.10
500			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
501	pcg	1.11	{
502			return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
503			}
504	pcg	1.10	};
505
506	pcg	1.12	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
507			struct callback<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
508	pcg	1.10	{
509	pcg	1.12	typedef R (ptr_type)(void self, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
510
511			private:
512
513			void *self;
514			ptr_type func;
515	pcg	1.10
516	pcg	1.12	protected:
517	pcg	1.10
518	pcg	1.12	template<typename method>
519			struct thunktype;
520	pcg	1.10
521	pcg	1.12	template<class klass>
522			struct thunktype<R (klass::*)>
523			{
524			typedef klass K;
525			};
526	pcg	1.10
527	pcg	1.12	template<class klass, R (klass::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
528			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)
529			{
530			klass obj = static_cast<klass >(self);
531			return (obj->*method) (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
532			}
533	pcg	1.10
534			public:
535	pcg	1.12	template<class K, R (K::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
536			void set (K *object)
537	pcg	1.11	{
538	pcg	1.12	self = object;
539			func = thunk<K, method>;
540	pcg	1.11	}
541
542	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
543	pcg	1.11	{
544	pcg	1.12	return func (self, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
545	pcg	1.11	}
546	pcg	1.10
547			R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
548	pcg	1.11	{
549			return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
550			}
551	pcg	1.10	};
552
553
554	pcg	1.1	#endif