rxvt-unicode/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 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 VPE_CALLBACK_H__
#define VPE_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.1
Committed:	Mon Nov 24 17:28:08 2003 UTC (20 years, 6 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-1-3, rel-1-2
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.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 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 VPE_CALLBACK_H__
28			#define VPE_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