server/include/callback.pl

#!/usr/bin/perl

print <<EOF;
// 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-2006 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 2

template<class signature>
struct callback_funtype_trait;

template<int arity, class signature>
struct callback_get_impl;

EOF

for my $a (0..10) {
   my $CLASS     = join "", map ", class A$_", 1..$a;
   my $TYPE      = join ", ", map "A$_", 1..$a;
   my $ARG       = join ", ", map "a$_", 1..$a;
   my $TYPEARG   = join ", ", map "A$_ a$_", 1..$a;
   my $TYPEDEFS  = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
   my $TYPEvoid  = $TYPE    ? $TYPE        : "void";
   my $_TYPE     = $TYPE    ? ", $TYPE"    : "";
   my $_ARG      = $ARG     ? ", $ARG"     : "";
   my $_TYPEARG  = $TYPEARG ? ", $TYPEARG" : "";
   my $_TTYPE    = $a       ? join "", map ", typename T::arg$_\_type", 1..$a : "";
   
   print <<EOF;
template<class R$CLASS>
class callback$a
{
  struct object { };

  typedef R (object::*ptr_type)($TYPE);

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

  /* 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)($TYPE)$_TYPEARG) const = 0;
  };
  template<class O1, class O2>
  struct proxy : proxy_base {
    virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG) const
      {
        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)($TYPE)>(meth)))
          ($ARG);
      }
  };

  proxy_base *prxy;

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

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

  R operator ()($TYPEARG) const
    {
      return call ($ARG);
    }
};

template<class R$CLASS>
struct callback_funtype_trait$a
{
  static const int arity = $a;
  typedef R type ($TYPEvoid);
  typedef R result_type;
  $TYPEDEFS
};

template<class R$CLASS>
struct callback_funtype_trait<R ($TYPE)> : callback_funtype_trait$a<R$_TYPE>
{
};

template<class signature>
struct callback_get_impl<$a, signature>
{
  typedef callback_funtype_trait<signature> T;
  typedef callback$a<typename T::result_type$_TTYPE> type;
};
   
EOF
}

print <<EOF

template<class signature>
struct callback : callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type
{
  typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;

  template<class O, class M>
  explicit callback (O object, M method)
    : base_type (object, method)
    {
    }
};

#endif
EOF

Revision:	1.2
Committed:	Sun Nov 18 00:06:52 2018 UTC (5 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#!/usr/bin/perl
2
3			print <<EOF;
4			// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
5			// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
6			// THIS IS A GENERATED FILE: distribution.
7
8			/*
9			callback.h -- C++ callback mechanism
10			Copyright (C) 2003-2006 Marc Lehmann <pcg\@goof.com>
11
12			This file is part of GVPE.
13
14			GVPE is free software; you can redistribute it and/or modify
15			it under the terms of the GNU General Public License as published by
16			the Free Software Foundation; either version 2 of the License, or
17			(at your option) any later version.
18
19			This program is distributed in the hope that it will be useful,
20			but WITHOUT ANY WARRANTY; without even the implied warranty of
21			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22			GNU General Public License for more details.
23
24			You should have received a copy of the GNU General Public License
25			along with gvpe; if not, write to the Free Software
26			Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27			*/
28
29			#ifndef CALLBACK_H__
30			#define CALLBACK_H__
31
32			#define CALLBACK_H_VERSION 2
33
34			template<class signature>
35			struct callback_funtype_trait;
36
37			template<int arity, class signature>
38			struct callback_get_impl;
39
40			EOF
41
42			for my $a (0..10) {
43			my $CLASS = join "", map ", class A$_", 1..$a;
44			my $TYPE = join ", ", map "A$_", 1..$a;
45			my $ARG = join ", ", map "a$_", 1..$a;
46			my $TYPEARG = join ", ", map "A$_ a$_", 1..$a;
47			my $TYPEDEFS = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
48			my $TYPEvoid = $TYPE ? $TYPE : "void";
49			my $_TYPE = $TYPE ? ", $TYPE" : "";
50			my $_ARG = $ARG ? ", $ARG" : "";
51			my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : "";
52			my $_TTYPE = $a ? join "", map ", typename T::arg$_\_type", 1..$a : "";
53
54			print <<EOF;
55			template<class R$CLASS>
56			class callback$a
57			{
58			struct object { };
59
60			typedef R (object::*ptr_type)($TYPE);
61
62			void *obj;
63			R (object::*meth)($TYPE);
64
65			/* a proxy is a kind of recipe on how to call a specific class method */
66			struct proxy_base {
67			virtual R call (void obj, R (object::meth)($TYPE)$_TYPEARG) const = 0;
68			};
69			template<class O1, class O2>
70			struct proxy : proxy_base {
71			virtual R call (void obj, R (object::meth)($TYPE)$_TYPEARG) const
72			{
73			return (R)((reinterpret_cast<O1 >(obj)) -> (reinterpret_cast<R (O2::*)($TYPE)>(meth)))
74			($ARG);
75			}
76			};
77
78			proxy_base *prxy;
79
80			public:
81			template<class O1, class O2>
82			explicit callback$a (O1 object, R (O2::method)($TYPE))
83			{
84			static proxy<O1,O2> p;
85			obj = reinterpret_cast<void *>(object);
86			meth = reinterpret_cast<R (object::*)($TYPE)>(method);
87			prxy = &p;
88			}
89
90			R call($TYPEARG) const
91			{
92			return prxy->call (obj, meth$_ARG);
93			}
94
95			R operator ()($TYPEARG) const
96			{
97			return call ($ARG);
98			}
99			};
100
101			template<class R$CLASS>
102			struct callback_funtype_trait$a
103			{
104			static const int arity = $a;
105			typedef R type ($TYPEvoid);
106			typedef R result_type;
107			$TYPEDEFS
108			};
109
110			template<class R$CLASS>
111			struct callback_funtype_trait<R ($TYPE)> : callback_funtype_trait$a<R$_TYPE>
112			{
113			};
114
115			template<class signature>
116			struct callback_get_impl<$a, signature>
117			{
118			typedef callback_funtype_trait<signature> T;
119			typedef callback$a<typename T::result_type$_TTYPE> type;
120			};
121
122			EOF
123			}
124
125			print <<EOF
126
127			template<class signature>
128			struct callback : callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type
129			{
130			typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;
131
132			template<class O, class M>
133			explicit callback (O object, M method)
134			: base_type (object, method)
135			{
136			}
137			};
138
139			#endif
140			EOF
141