[pclasses-cvs] pclasses2/include/pclasses CallbackN.sh,NONE,1.1

[Christian P. <cp...@us...>]

Update of /cvsroot/pclasses/pclasses2/include/pclasses
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30783/include/pclasses

Added Files:
	CallbackN.sh 
Log Message:
Added CallbackN generation shell-script 

--- NEW FILE: CallbackN.sh ---
#/***************************************************************************
# *   Copyright (C) 2005 by Christian Prochnow                              *
# *   cp...@se...                                                   *
# *                                                                         *
# *   This program is free software; you can redistribute it and/or modify  *
# *   it under the terms of the GNU Library 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 Library 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.             *
# ***************************************************************************/

#
# this shell-script generates code for Signals with n arguments....
#

generate_callbackN()
{
templateargs="typename _ArgT1"
structmembers="_ArgT1 arg1;"
argtypes="_ArgT1"
argtypescp=", _ArgT1"
argtypeswname="_ArgT1 arg1"
args="arg1"
argsassign="args.arg1 = arg1;"
callargs="a->arg1"

num=1
while [ "$num" -lt "$1" ]
do
	num=`expr $num + 1`
	templateargs="$templateargs, typename _ArgT$num"
	structmembers="$structmembers _ArgT$num arg$num;"
	argtypes="$argtypes, _ArgT$num"
	argtypescp="$argtypescp, _ArgT$num"
	argtypeswname="$argtypeswname, _ArgT$num arg$num"
	args="$args, arg$num"
	argsassign="$argsassign args.arg$num = arg$num;"
	callargs="$callargs, a->arg$num"
done

cat <<- EOF > "CallbackN$1.h"
namespace P {

/* ----------------- Callback1 ------------------ */

template <$templateargs>
struct CallbackArgs$num: CallbackArgs { $structmembers };

template <$templateargs>
CallbackArgs$num<$argtypes> make_args($argtypeswname)
{
	CallbackArgs$num<$argtypes> args;
	$argsassign
	return args;
}

//! Callback base class with $num argument
template <typename _RetT, $templateargs>
class Callback$num: public Callback {
	public:
		typedef CallbackArgs$num<$argtypes> Args;
		struct RetType: public Callback::RetType { _RetT retVal; };

		Callback$num() { }
		virtual ~Callback$num() { }

		Callback::RetType exec(const CallbackArgs& args) const
		{
			RetType ret;
			const Args* a = static_cast<const Args*>(&args);
			if(!a) throw;
			ret.retVal = exec($callargs);
			return ret;
		}

		virtual _RetT exec($argtypes) const = 0;
};

//! Callback base class with $num argument (void specialisation)
template <$templateargs>
class Callback$num<void $argtypescp>: public Callback {
	public:
		typedef CallbackArgs$num<$argtypes> Args;
		struct RetType: public Callback::RetType { };
	
		Callback$num() { }
		virtual ~Callback$num() { }

		Callback::RetType exec(const CallbackArgs& args) const
		{
			const Args* a = static_cast<const Args*>(&args);
			if(!a) throw;
			exec($callargs);
			return RetType();
		}

		virtual void exec($argtypes) const = 0;
};

/* -------------- Function1 ------------- */

//! Function callback class with $num argument
template <typename _RetT, $templateargs>
class Function$num: public Callback$num<_RetT, $argtypes> {
	public:
		typedef _RetT (*FuncPtr)($argtypes);

		Function$num(FuncPtr ptr)
		: _funcPtr(ptr) { }

		_RetT exec($argtypeswname) const
		{ return (*_funcPtr)($args); }

		Callback$num<_RetT, $argtypes>* clone() const
		{ return new Function$num(*this); }

		bool operator==(const Function$num& f) const
		{ return _funcPtr == f._funcPtr; }

	private:
		FuncPtr _funcPtr;
};

//! Function callback class with $num argument (void specialisation)
template <$templateargs>
class Function$num<void, $argtypes>: public Callback$num<void, $argtypes> {
	public:
		typedef void (*FuncPtr)($argtypes);

		Function$num(FuncPtr ptr)
		: _funcPtr(ptr) { }

		void exec($argtypeswname) const
		{ (*_funcPtr)($args); }

		Callback$num<void, $argtypes>* clone() const
		{ return new Function$num(*this); }

		bool operator==(const Function$num& f) const
		{ return _funcPtr == f._funcPtr; }

	private:
		FuncPtr _funcPtr;
};

//! Returns a function-callback object
template <typename _RetT, $templateargs>
Function$num<_RetT, $argtypes> make_function(_RetT (*ptr)($argtypes))
{ return Function$num<_RetT, $argtypes>(ptr); }

/* ---------- Method1 ------------ */

//! Method callback class with $num arguments
template <typename _RetT, class _ObjT, $templateargs>
class Method$num: public Callback$num<_RetT, $argtypes> {
	public:
		typedef _RetT (_ObjT::*FuncPtr)($argtypes);

		Method$num(_ObjT* obj, FuncPtr ptr)
		: _obj(obj), _funcPtr(ptr) { }

		_RetT exec($argtypeswname) const
		{ return (_obj->*_funcPtr)($args); }

		Callback$num<_RetT, $argtypes>* clone() const
		{ return new Method$num(*this); }

		bool operator==(const Method$num& f) const
		{ return _obj == f._obj && _funcPtr == f._funcPtr; }

	private:
		_ObjT*  _obj;
		FuncPtr _funcPtr;
};

//! Method callback class with $num arguments (void specialisation)
template <class _ObjT, $templateargs>
class Method$num<void, _ObjT, $argtypes>: public Callback$num<void, $argtypes> {
	public:
		typedef void (_ObjT::*FuncPtr)($argtypes);

		Method$num(_ObjT* obj, FuncPtr ptr)
		: _obj(obj), _funcPtr(ptr) { }

		void exec($argtypeswname) const
		{ (_obj->*_funcPtr)($args); }

		Callback$num<void, $argtypes>* clone() const
		{ return new Method$num(*this); }

		bool operator==(const Method$num& f) const
		{ return _obj == f._obj && _funcPtr == f._funcPtr; }

	private:
		_ObjT*  _obj;
		FuncPtr _funcPtr;
};

//! Returns a method-callback object
template <typename _RetT, class _ObjT, $templateargs>
Method$num<_RetT, _ObjT, $argtypes> make_method(_ObjT* obj, _RetT (_ObjT::*ptr)($argtypes))
{ return Method$num<_RetT, _ObjT, $argtypes>(obj, ptr); }

} // !namespace P
EOF
}

generate_callbackN 1
generate_callbackN 2
generate_callbackN 3
generate_callbackN 4