head	1.1;
access;
symbols;
locks; strict;
comment	@# @;


1.1
date	2005.09.09.01.18.12;	author myevan;	state Exp;
branches;
next	;


desc
@@


1.1
log
@ó 
@
text
@/*

	Method Template

	Usage:

		self_method_iter(this, &CTest::Run);			== bind1st(mem_fun1(&CTest::Run), this);
		self_method_iter(this, &CTest::Run, "arg");		== X
		iter_method(&CItem::Clone);						== mem_fun(&CItemClone);
		iter_method(&CItem::Clone, "arg");				== bind2nd(mem_fun1(&CItem::Clone), "arg");

*/
#pragma once

namespace eter {

/////////////////////

template<typename SELF, typename METHOD, typename EACH, typename RET>
class self_method_iter0_t
{
public:
	inline self_method_iter0_t(SELF* self, METHOD method) : m_self(self), m_method(method) {}
	inline RET operator() (EACH each)	
	{return (m_self->*m_method)(each);}

private:
	METHOD m_method;	
	SELF* m_self;
};

template<typename SELF, typename RET, typename EACH>
inline self_method_iter0_t<SELF, RET (SELF::*)(EACH), EACH, RET>
self_method_iter(SELF* self, RET (SELF::*method)(EACH))
{
	return self_method_iter0_t<SELF, RET (SELF::*)(EACH), EACH, RET>(self, method);
}

/////////////////////

template<typename SELF, typename METHOD, typename EACH, typename ARG, typename RET>
class self_method_iter1_t
{
public:
	inline self_method_iter1_t(SELF* self, METHOD method, ARG arg) : m_self(self), m_method(method), m_arg(arg) {}
	inline RET operator() (EACH each)	
	{return (m_self->*m_method)(each, m_arg);}

private:
	METHOD m_method;	
	ARG m_arg;
	SELF* m_self;
};


template<typename SELF, typename RET, typename EACH, typename ARG, typename ARG_CREF>
inline self_method_iter1_t<SELF, RET (SELF::*)(EACH, ARG_CREF), EACH, ARG_CREF, RET>
self_method_iter(SELF* self, RET (SELF::*method)(EACH, ARG_CREF), const ARG& arg)
{
	return self_method_iter1_t<SELF, RET (SELF::*)(EACH, ARG_CREF), EACH, ARG_CREF, RET>(self, method, arg);
}

/////////////////////

template<typename EACH, typename METHOD, typename RET>
class iter_method0_t
{
public:
	inline iter_method0_t(METHOD method) : m_method(method) {}
	inline RET operator() (EACH* each)	
	{return (each->*m_method)();}

private:
	METHOD m_method;	
};

template<typename SELF, typename RET>
inline iter_method0_t<SELF, RET (SELF::*)(), RET>
iter_method(RET (SELF::*method)())
{
	return iter_method0_t<SELF, RET (SELF::*)(), RET>(method);
}

template<typename SELF, typename RET>
inline iter_method0_t<SELF, RET (SELF::*)() const, RET>
iter_method(RET (SELF::*method)() const)
{
	return iter_method0_t<SELF, RET (SELF::*)() const, RET>(method);
}

/////////////////////

template<typename EACH, typename METHOD, typename ARG, typename RET>
class iter_method1_t
{
public:
	inline iter_method1_t(METHOD method, ARG arg) : m_method(method), m_arg(arg) {}
	inline RET operator() (EACH* EACH)	
	{return (EACH->*m_method)(m_arg);}

private:
	METHOD m_method;	
	ARG	m_arg;
};

template<typename EACH, typename ARG, typename RET, typename ARG_CREF>
inline iter_method1_t<EACH, RET (EACH::*)(ARG_CREF), ARG_CREF, RET>
iter_method(RET (EACH::*method)(ARG_CREF), ARG& arg)
{
	return iter_method1_t<EACH, RET (EACH::*)(ARG_CREF), ARG_CREF, RET>(method, arg);
}

/////////////////////

template<typename EACH, typename METHOD, typename ARG1, typename ARG2, typename RET>
class iter_method2_t
{
public:
	inline iter_method2_t(METHOD method, ARG1 arg1, ARG2 arg2) : m_method(method), m_arg1(arg1), m_arg2(arg2) {}
	inline RET operator() (EACH* EACH)	
	{return (EACH->*m_method)(m_arg1, m_arg2);}

private:
	METHOD m_method;	
	ARG1	m_arg1;
	ARG2	m_arg2;
};

template<typename EACH, typename ARG1, typename ARG2, typename RET, typename ARG_CREF1, typename ARG_CREF2>
inline iter_method2_t<EACH, RET (EACH::*)(ARG_CREF1, ARG_CREF2), ARG_CREF1, ARG_CREF2, RET>
iter_method(RET (EACH::*method)(ARG_CREF1, ARG_CREF2), ARG1& arg1, ARG2& arg2)
{
	return iter_method2_t<EACH, RET (EACH::*)(ARG_CREF1, ARG_CREF2), ARG_CREF1, ARG_CREF2, RET>(method, arg1, arg2);
}

} // eter@
