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 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.3
Committed:	Fri Feb 13 12:16:21 2004 UTC (20 years, 3 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_1_0, rel-4_8, rel-4_9, rel-4_4, rel-4_6, rel-4_7, rel-4_0, rel-4_1, rel-4_2, rel-4_3, rel-2_8, rel-2_7, rel-2_4, rel-2_5, rel-2_2, rel-2_3, rel-2_0, rel-1_9, rel-5_5, rel-5_4, rel-5_1, rel-5_0, rel-5_3, rel-5_2, rel-3_7, rel-3_6, rel-3_5, rel-3_4, rel-3_3, rel-3_2, rel-3_0, rel-3_8
Changes since 1.2:	+72 -72 lines
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	pcg	1.2	#ifndef CALLBACK_H__
28			#define CALLBACK_H__
29	pcg	1.1
30			template<class R>
31			class callback0 {
32			struct object { };
33
34			void *obj;
35	pcg	1.3	R (object::*meth) ();
36	pcg	1.1
37			/* a proxy is a kind of recipe on how to call a specific class method */
38			struct proxy_base {
39	pcg	1.3	virtual R call (void obj, R (object::meth) ()) = 0;
40	pcg	1.1	};
41			template<class O1, class O2>
42			struct proxy : proxy_base {
43	pcg	1.3	virtual R call (void obj, R (object::meth) ())
44	pcg	1.1	{
45	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) ()> (meth)))
46	pcg	1.1	();
47			}
48			};
49
50			proxy_base *prxy;
51
52			public:
53			template<class O1, class O2>
54	pcg	1.3	callback0 (O1 object, R (O2::method) ())
55	pcg	1.1	{
56			static proxy<O1,O2> p;
57	pcg	1.3	obj = reinterpret_cast<void *> (object);
58			meth = reinterpret_cast<R (object::*) ()> (method);
59	pcg	1.1	prxy = &p;
60			}
61
62	pcg	1.3	R call () const
63	pcg	1.1	{
64			return prxy->call (obj, meth);
65			}
66
67	pcg	1.3	R operator () () const
68	pcg	1.1	{
69			return call ();
70			}
71			};
72
73			template<class R, class A1>
74			class callback1 {
75			struct object { };
76
77			void *obj;
78	pcg	1.3	R (object::*meth) (A1);
79	pcg	1.1
80			/* a proxy is a kind of recipe on how to call a specific class method */
81			struct proxy_base {
82	pcg	1.3	virtual R call (void obj, R (object::meth) (A1), A1 a1) = 0;
83	pcg	1.1	};
84			template<class O1, class O2>
85			struct proxy : proxy_base {
86	pcg	1.3	virtual R call (void obj, R (object::meth) (A1), A1 a1)
87	pcg	1.1	{
88	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) (A1)> (meth)))
89	pcg	1.1	(a1);
90			}
91			};
92
93			proxy_base *prxy;
94
95			public:
96			template<class O1, class O2>
97	pcg	1.3	callback1 (O1 object, R (O2::method) (A1))
98	pcg	1.1	{
99			static proxy<O1,O2> p;
100	pcg	1.3	obj = reinterpret_cast<void *> (object);
101			meth = reinterpret_cast<R (object::*) (A1)> (method);
102	pcg	1.1	prxy = &p;
103			}
104
105	pcg	1.3	R call (A1 a1) const
106	pcg	1.1	{
107			return prxy->call (obj, meth, a1);
108			}
109
110	pcg	1.3	R operator () (A1 a1) const
111	pcg	1.1	{
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	pcg	1.3	R (object::*meth) (A1, A2);
122	pcg	1.1
123			/* a proxy is a kind of recipe on how to call a specific class method */
124			struct proxy_base {
125	pcg	1.3	virtual R call (void obj, R (object::meth) (A1, A2), A1 a1, A2 a2) = 0;
126	pcg	1.1	};
127			template<class O1, class O2>
128			struct proxy : proxy_base {
129	pcg	1.3	virtual R call (void obj, R (object::meth) (A1, A2), A1 a1, A2 a2)
130	pcg	1.1	{
131	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) (A1, A2)> (meth)))
132	pcg	1.1	(a1, a2);
133			}
134			};
135
136			proxy_base *prxy;
137
138			public:
139			template<class O1, class O2>
140	pcg	1.3	callback2 (O1 object, R (O2::method) (A1, A2))
141	pcg	1.1	{
142			static proxy<O1,O2> p;
143	pcg	1.3	obj = reinterpret_cast<void *> (object);
144			meth = reinterpret_cast<R (object::*) (A1, A2)> (method);
145	pcg	1.1	prxy = &p;
146			}
147
148	pcg	1.3	R call (A1 a1, A2 a2) const
149	pcg	1.1	{
150			return prxy->call (obj, meth, a1, a2);
151			}
152
153	pcg	1.3	R operator () (A1 a1, A2 a2) const
154	pcg	1.1	{
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	pcg	1.3	R (object::*meth) (A1, A2, A3);
165	pcg	1.1
166			/* a proxy is a kind of recipe on how to call a specific class method */
167			struct proxy_base {
168	pcg	1.3	virtual R call (void obj, R (object::meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
169	pcg	1.1	};
170			template<class O1, class O2>
171			struct proxy : proxy_base {
172	pcg	1.3	virtual R call (void obj, R (object::meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3)
173	pcg	1.1	{
174	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) (A1, A2, A3)> (meth)))
175	pcg	1.1	(a1, a2, a3);
176			}
177			};
178
179			proxy_base *prxy;
180
181			public:
182			template<class O1, class O2>
183	pcg	1.3	callback3 (O1 object, R (O2::method) (A1, A2, A3))
184	pcg	1.1	{
185			static proxy<O1,O2> p;
186	pcg	1.3	obj = reinterpret_cast<void *> (object);
187			meth = reinterpret_cast<R (object::*) (A1, A2, A3)> (method);
188	pcg	1.1	prxy = &p;
189			}
190
191	pcg	1.3	R call (A1 a1, A2 a2, A3 a3) const
192	pcg	1.1	{
193			return prxy->call (obj, meth, a1, a2, a3);
194			}
195
196	pcg	1.3	R operator () (A1 a1, A2 a2, A3 a3) const
197	pcg	1.1	{
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	pcg	1.3	R (object::*meth) (A1, A2, A3, A4);
208	pcg	1.1
209			/* a proxy is a kind of recipe on how to call a specific class method */
210			struct proxy_base {
211	pcg	1.3	virtual R call (void obj, R (object::meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
212	pcg	1.1	};
213			template<class O1, class O2>
214			struct proxy : proxy_base {
215	pcg	1.3	virtual R call (void obj, R (object::meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
216	pcg	1.1	{
217	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) (A1, A2, A3, A4)> (meth)))
218	pcg	1.1	(a1, a2, a3, a4);
219			}
220			};
221
222			proxy_base *prxy;
223
224			public:
225			template<class O1, class O2>
226	pcg	1.3	callback4 (O1 object, R (O2::method) (A1, A2, A3, A4))
227	pcg	1.1	{
228			static proxy<O1,O2> p;
229	pcg	1.3	obj = reinterpret_cast<void *> (object);
230			meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4)> (method);
231	pcg	1.1	prxy = &p;
232			}
233
234	pcg	1.3	R call (A1 a1, A2 a2, A3 a3, A4 a4) const
235	pcg	1.1	{
236			return prxy->call (obj, meth, a1, a2, a3, a4);
237			}
238
239	pcg	1.3	R operator () (A1 a1, A2 a2, A3 a3, A4 a4) const
240	pcg	1.1	{
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	pcg	1.3	R (object::*meth) (A1, A2, A3, A4, A5);
251	pcg	1.1
252			/* a proxy is a kind of recipe on how to call a specific class method */
253			struct proxy_base {
254	pcg	1.3	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	pcg	1.1	};
256			template<class O1, class O2>
257			struct proxy : proxy_base {
258	pcg	1.3	virtual R call (void obj, R (object::meth) (A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
259	pcg	1.1	{
260	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5)> (meth)))
261	pcg	1.1	(a1, a2, a3, a4, a5);
262			}
263			};
264
265			proxy_base *prxy;
266
267			public:
268			template<class O1, class O2>
269	pcg	1.3	callback5 (O1 object, R (O2::method) (A1, A2, A3, A4, A5))
270	pcg	1.1	{
271			static proxy<O1,O2> p;
272	pcg	1.3	obj = reinterpret_cast<void *> (object);
273			meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5)> (method);
274	pcg	1.1	prxy = &p;
275			}
276
277	pcg	1.3	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
278	pcg	1.1	{
279			return prxy->call (obj, meth, a1, a2, a3, a4, a5);
280			}
281
282	pcg	1.3	R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
283	pcg	1.1	{
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	pcg	1.3	R (object::*meth) (A1, A2, A3, A4, A5, A6);
294	pcg	1.1
295			/* a proxy is a kind of recipe on how to call a specific class method */
296			struct proxy_base {
297	pcg	1.3	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	pcg	1.1	};
299			template<class O1, class O2>
300			struct proxy : proxy_base {
301	pcg	1.3	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	pcg	1.1	{
303	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6)> (meth)))
304	pcg	1.1	(a1, a2, a3, a4, a5, a6);
305			}
306			};
307
308			proxy_base *prxy;
309
310			public:
311			template<class O1, class O2>
312	pcg	1.3	callback6 (O1 object, R (O2::method) (A1, A2, A3, A4, A5, A6))
313	pcg	1.1	{
314			static proxy<O1,O2> p;
315	pcg	1.3	obj = reinterpret_cast<void *> (object);
316			meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6)> (method);
317	pcg	1.1	prxy = &p;
318			}
319
320	pcg	1.3	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
321	pcg	1.1	{
322			return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
323			}
324
325	pcg	1.3	R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
326	pcg	1.1	{
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	pcg	1.3	R (object::*meth) (A1, A2, A3, A4, A5, A6, A7);
337	pcg	1.1
338			/* a proxy is a kind of recipe on how to call a specific class method */
339			struct proxy_base {
340	pcg	1.3	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	pcg	1.1	};
342			template<class O1, class O2>
343			struct proxy : proxy_base {
344	pcg	1.3	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	pcg	1.1	{
346	pcg	1.3	((reinterpret_cast<O1 > (obj)) -> (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6, A7)> (meth)))
347	pcg	1.1	(a1, a2, a3, a4, a5, a6, a7);
348			}
349			};
350
351			proxy_base *prxy;
352
353			public:
354			template<class O1, class O2>
355	pcg	1.3	callback7 (O1 object, R (O2::method) (A1, A2, A3, A4, A5, A6, A7))
356	pcg	1.1	{
357			static proxy<O1,O2> p;
358	pcg	1.3	obj = reinterpret_cast<void *> (object);
359			meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6, A7)> (method);
360	pcg	1.1	prxy = &p;
361			}
362
363	pcg	1.3	R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
364	pcg	1.1	{
365			return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
366			}
367
368	pcg	1.3	R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
369	pcg	1.1	{
370			return call (a1, a2, a3, a4, a5, a6, a7);
371			}
372			};
373
374			#endif