rxvt-unicode/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-2005 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__

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