gvpe/src/callback.h

// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it

/*
    callback.h -- C++ callback mechanism
    Copyright (C) 2003-2004 Marc Lehmann <pcg@goof.com>
 
    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 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 this program; if not, write to the Free Software
    Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef CALLBACK_H__
#define CALLBACK_H__

template<class R>
class callback0 {
  struct object { };

  void *obj;
  R (object::*meth)();

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)()) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)())
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
          ();
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback0 (O1 *object, R (O2::*method)())
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)()>(method);
      prxy = &p;
    }

  R call() const
    {
      return prxy->call (obj, meth);
    }

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

template<class R, class A1>
class callback1 {
  struct object { };

  void *obj;
  R (object::*meth)(A1);

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1), A1 a1)
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
          (a1);
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback1 (O1 *object, R (O2::*method)(A1))
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)(A1)>(method);
      prxy = &p;
    }

  R call(A1 a1) const
    {
      return prxy->call (obj, meth, a1);
    }

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

template<class R, class A1, class A2>
class callback2 {
  struct object { };

  void *obj;
  R (object::*meth)(A1, A2);

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2)
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
          (a1, a2);
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback2 (O1 *object, R (O2::*method)(A1, A2))
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
      prxy = &p;
    }

  R call(A1 a1, A2 a2) const
    {
      return prxy->call (obj, meth, a1, a2);
    }

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

template<class R, class A1, class A2, class A3>
class callback3 {
  struct object { };

  void *obj;
  R (object::*meth)(A1, A2, A3);

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3)
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
          (a1, a2, a3);
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
      prxy = &p;
    }

  R call(A1 a1, A2 a2, A3 a3) const
    {
      return prxy->call (obj, meth, 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>
class callback4 {
  struct object { };

  void *obj;
  R (object::*meth)(A1, A2, A3, A4);

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
          (a1, a2, a3, a4);
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
      prxy = &p;
    }

  R call(A1 a1, A2 a2, A3 a3, A4 a4) const
    {
      return prxy->call (obj, meth, 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>
class callback5 {
  struct object { };

  void *obj;
  R (object::*meth)(A1, A2, A3, A4, A5);

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
          (a1, a2, a3, a4, a5);
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
      prxy = &p;
    }

  R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
      return prxy->call (obj, meth, 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>
class callback6 {
  struct object { };

  void *obj;
  R (object::*meth)(A1, A2, A3, A4, A5, A6);

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
          (a1, a2, a3, a4, a5, a6);
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
      prxy = &p;
    }

  R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
    {
      return prxy->call (obj, meth, 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>
class callback7 {
  struct object { };

  void *obj;
  R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);

  /* a proxy is a kind of recipe on how to call a specific class method */
  struct proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
      {
        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
          (a1, a2, a3, a4, a5, a6, a7);
      }
  };

  proxy_base *prxy;

public:
  template<class O1, class O2>
  callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
    {
      static proxy<O1,O2> p;
      obj  = reinterpret_cast<void *>(object);
      meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
      prxy = &p;
    }

  R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
    {
      return prxy->call (obj, meth, 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);
    }
};

#endif
Revision:	1.4
Committed:	Sat Jan 17 01:18:36 2004 UTC (21 years ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	VPE_1_4, VPE_1_6, rel-1_7, VPE-1_6_1
Changes since 1.3:	+3 -3 lines
Log Message:	* empty log message *
#	Content
1	// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
2	// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
3	// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
4	// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
5	// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
6	// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
7
8	/*
9	callback.h -- C++ callback mechanism
10	Copyright (C) 2003-2004 Marc Lehmann <pcg@goof.com>
11
12	This program is free software; you can redistribute it and/or modify
13	it under the terms of the GNU General Public License as published by
14	the Free Software Foundation; either version 2 of the License, or
15	(at your option) any later version.
16
17	This program is distributed in the hope that it will be useful,
18	but WITHOUT ANY WARRANTY; without even the implied warranty of
19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	GNU General Public License for more details.
21
22	You should have received a copy of the GNU General Public License
23	along with this program; if not, write to the Free Software
24	Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25	*/
26
27	#ifndef CALLBACK_H__
28	#define CALLBACK_H__
29
30	template<class R>
31	class callback0 {
32	struct object { };
33
34	void *obj;
35	R (object::*meth)();
36
37	/* a proxy is a kind of recipe on how to call a specific class method */
38	struct proxy_base {
39	virtual R call (void obj, R (object::meth)()) = 0;
40	};
41	template<class O1, class O2>
42	struct proxy : proxy_base {
43	virtual R call (void obj, R (object::meth)())
44	{
45	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)()>(meth)))
46	();
47	}
48	};
49
50	proxy_base *prxy;
51
52	public:
53	template<class O1, class O2>
54	callback0 (O1 object, R (O2::method)())
55	{
56	static proxy<O1,O2> p;
57	obj = reinterpret_cast<void *>(object);
58	meth = reinterpret_cast<R (object::*)()>(method);
59	prxy = &p;
60	}
61
62	R call() const
63	{
64	return prxy->call (obj, meth);
65	}
66
67	R operator ()() const
68	{
69	return call ();
70	}
71	};
72
73	template<class R, class A1>
74	class callback1 {
75	struct object { };
76
77	void *obj;
78	R (object::*meth)(A1);
79
80	/* a proxy is a kind of recipe on how to call a specific class method */
81	struct proxy_base {
82	virtual R call (void obj, R (object::meth)(A1), A1 a1) = 0;
83	};
84	template<class O1, class O2>
85	struct proxy : proxy_base {
86	virtual R call (void obj, R (object::meth)(A1), A1 a1)
87	{
88	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)(A1)>(meth)))
89	(a1);
90	}
91	};
92
93	proxy_base *prxy;
94
95	public:
96	template<class O1, class O2>
97	callback1 (O1 object, R (O2::method)(A1))
98	{
99	static proxy<O1,O2> p;
100	obj = reinterpret_cast<void *>(object);
101	meth = reinterpret_cast<R (object::*)(A1)>(method);
102	prxy = &p;
103	}
104
105	R call(A1 a1) const
106	{
107	return prxy->call (obj, meth, a1);
108	}
109
110	R operator ()(A1 a1) const
111	{
112	return call (a1);
113	}
114	};
115
116	template<class R, class A1, class A2>
117	class callback2 {
118	struct object { };
119
120	void *obj;
121	R (object::*meth)(A1, A2);
122
123	/* a proxy is a kind of recipe on how to call a specific class method */
124	struct proxy_base {
125	virtual R call (void obj, R (object::meth)(A1, A2), A1 a1, A2 a2) = 0;
126	};
127	template<class O1, class O2>
128	struct proxy : proxy_base {
129	virtual R call (void obj, R (object::meth)(A1, A2), A1 a1, A2 a2)
130	{
131	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
132	(a1, a2);
133	}
134	};
135
136	proxy_base *prxy;
137
138	public:
139	template<class O1, class O2>
140	callback2 (O1 object, R (O2::method)(A1, A2))
141	{
142	static proxy<O1,O2> p;
143	obj = reinterpret_cast<void *>(object);
144	meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
145	prxy = &p;
146	}
147
148	R call(A1 a1, A2 a2) const
149	{
150	return prxy->call (obj, meth, a1, a2);
151	}
152
153	R operator ()(A1 a1, A2 a2) const
154	{
155	return call (a1, a2);
156	}
157	};
158
159	template<class R, class A1, class A2, class A3>
160	class callback3 {
161	struct object { };
162
163	void *obj;
164	R (object::*meth)(A1, A2, A3);
165
166	/* a proxy is a kind of recipe on how to call a specific class method */
167	struct proxy_base {
168	virtual R call (void obj, R (object::meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
169	};
170	template<class O1, class O2>
171	struct proxy : proxy_base {
172	virtual R call (void obj, R (object::meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3)
173	{
174	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
175	(a1, a2, a3);
176	}
177	};
178
179	proxy_base *prxy;
180
181	public:
182	template<class O1, class O2>
183	callback3 (O1 object, R (O2::method)(A1, A2, A3))
184	{
185	static proxy<O1,O2> p;
186	obj = reinterpret_cast<void *>(object);
187	meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
188	prxy = &p;
189	}
190
191	R call(A1 a1, A2 a2, A3 a3) const
192	{
193	return prxy->call (obj, meth, a1, a2, a3);
194	}
195
196	R operator ()(A1 a1, A2 a2, A3 a3) const
197	{
198	return call (a1, a2, a3);
199	}
200	};
201
202	template<class R, class A1, class A2, class A3, class A4>
203	class callback4 {
204	struct object { };
205
206	void *obj;
207	R (object::*meth)(A1, A2, A3, A4);
208
209	/* a proxy is a kind of recipe on how to call a specific class method */
210	struct proxy_base {
211	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
212	};
213	template<class O1, class O2>
214	struct proxy : proxy_base {
215	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
216	{
217	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
218	(a1, a2, a3, a4);
219	}
220	};
221
222	proxy_base *prxy;
223
224	public:
225	template<class O1, class O2>
226	callback4 (O1 object, R (O2::method)(A1, A2, A3, A4))
227	{
228	static proxy<O1,O2> p;
229	obj = reinterpret_cast<void *>(object);
230	meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
231	prxy = &p;
232	}
233
234	R call(A1 a1, A2 a2, A3 a3, A4 a4) const
235	{
236	return prxy->call (obj, meth, a1, a2, a3, a4);
237	}
238
239	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
240	{
241	return call (a1, a2, a3, a4);
242	}
243	};
244
245	template<class R, class A1, class A2, class A3, class A4, class A5>
246	class callback5 {
247	struct object { };
248
249	void *obj;
250	R (object::*meth)(A1, A2, A3, A4, A5);
251
252	/* a proxy is a kind of recipe on how to call a specific class method */
253	struct proxy_base {
254	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
255	};
256	template<class O1, class O2>
257	struct proxy : proxy_base {
258	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
259	{
260	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
261	(a1, a2, a3, a4, a5);
262	}
263	};
264
265	proxy_base *prxy;
266
267	public:
268	template<class O1, class O2>
269	callback5 (O1 object, R (O2::method)(A1, A2, A3, A4, A5))
270	{
271	static proxy<O1,O2> p;
272	obj = reinterpret_cast<void *>(object);
273	meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
274	prxy = &p;
275	}
276
277	R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
278	{
279	return prxy->call (obj, meth, a1, a2, a3, a4, a5);
280	}
281
282	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
283	{
284	return call (a1, a2, a3, a4, a5);
285	}
286	};
287
288	template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
289	class callback6 {
290	struct object { };
291
292	void *obj;
293	R (object::*meth)(A1, A2, A3, A4, A5, A6);
294
295	/* a proxy is a kind of recipe on how to call a specific class method */
296	struct proxy_base {
297	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
298	};
299	template<class O1, class O2>
300	struct proxy : proxy_base {
301	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
302	{
303	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
304	(a1, a2, a3, a4, a5, a6);
305	}
306	};
307
308	proxy_base *prxy;
309
310	public:
311	template<class O1, class O2>
312	callback6 (O1 object, R (O2::method)(A1, A2, A3, A4, A5, A6))
313	{
314	static proxy<O1,O2> p;
315	obj = reinterpret_cast<void *>(object);
316	meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
317	prxy = &p;
318	}
319
320	R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
321	{
322	return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
323	}
324
325	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
326	{
327	return call (a1, a2, a3, a4, a5, a6);
328	}
329	};
330
331	template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
332	class callback7 {
333	struct object { };
334
335	void *obj;
336	R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
337
338	/* a proxy is a kind of recipe on how to call a specific class method */
339	struct proxy_base {
340	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
341	};
342	template<class O1, class O2>
343	struct proxy : proxy_base {
344	virtual R call (void obj, R (object::meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
345	{
346	((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
347	(a1, a2, a3, a4, a5, a6, a7);
348	}
349	};
350
351	proxy_base *prxy;
352
353	public:
354	template<class O1, class O2>
355	callback7 (O1 object, R (O2::method)(A1, A2, A3, A4, A5, A6, A7))
356	{
357	static proxy<O1,O2> p;
358	obj = reinterpret_cast<void *>(object);
359	meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
360	prxy = &p;
361	}
362
363	R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
364	{
365	return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
366	}
367
368	R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
369	{
370	return call (a1, a2, a3, a4, a5, a6, a7);
371	}
372	};
373
374	#endif