| Цитата(Chaos @ 22.8.2005, 08:09) | | AtroX, было бы интересно посмотреть, как ты решил проблему. |
Так оно применяется (что вполне меня устраивает):
main.cpp
| Код |
#include "entity.h"
#include "trait.h"
class SomeEntity1 : public BaseEntity {
public:
virtual void f1(void) {
Dispatch(f1);
return ;
}
virtual int f2(float p1) {
Dispatch(f2, p1);
return 0;
}
};
class SomeEntity2 : public SomeEntity1 {
public:
void f3(int p1) {
Dispatch(f3, p1);
return ;
}
};
class SomeTrait1 : public BaseTrait {
public:
virtual void f1(void) {
return ;
}
virtual int f2(float p1) {
return 0;
}
virtual void AttachTo(BaseEntity *pEntity) {
BaseTrait::AttachTo(pEntity);
pEntity->Attach(SomeEntity1::f1, makeTraitFn(this, f1));
pEntity->Attach(SomeEntity1::f2, makeTraitFn(this, f2));
}
};
class SomeTrait2 : public SomeTrait1 {
public:
virtual void f1() {
return SomeTrait1::f1();
}
virtual void f3(int p1) {
return ;
}
virtual void AttachTo(BaseEntity *pEntity) {
SomeTrait1::AttachTo(pEntity);
pEntity->Attach(SomeEntity2::f3, makeTraitFn(this, f3));
}
};
void main ()
{
SomeEntity2 e;
BaseTrait *pTrait = 0;
pTrait = new SomeTrait1;
pTrait->AttachTo(&e);
pTrait = new SomeTrait2;
pTrait->AttachTo(&e);
e.f1(); //SomeTrait1::f1, SomeTrait2::f1
e.f2(2.f);//SomeTrait1::f2, SomeTrait1::f2
e.f3(2); //SomeTrait2::f3
}
|
Собственно то, что позволило так кратенько все записывать, хотя я думаю, что все это нафиг переделаю
MemberFn.h
| Код |
#pragma once
//
// functors for Member function
template <typename T> class BaseMemFn {
public:
typedef T CLASS_T;
BaseMemFn(CLASS_T *pC) : class_ptr(pC) { return ; }
CLASS_T* GetClass(void) const { return class_ptr; }
private:
CLASS_T* class_ptr;// here must be smart_ptr with ref counting
};
//
// Functor with 1 param
template <typename T, typename R, typename P1 = void> class MemFn : public BaseMemFn<T> {
public:
typedef R (T::*FN_T)(P1);
FN_T fn;
MemFn(T *pC, FN_T _fn) : BaseMemFn<T>(pC), fn(_fn) {}
R operator()(P1 p1) {
return (GetClass()->*fn)(p1);
}
};
template <typename T, typename C, typename R, typename P1> MemFn<T,R,P1> makeFunctor(T* pClass, R (C::*fn)(P1))
{
return MemFn<T,R,P1>(pClass, static_cast<MemFn<T,R,P1>::FN_T>(fn));
}
//
// Functor with 0 params
template <typename T, typename R> class MemFn<T,R, void> : public BaseMemFn<T> {
public:
typedef R (T::*FN_T)();
FN_T fn;
MemFn(T *pC, FN_T _fn) : BaseMemFn<T>(pC), fn(_fn) {}
R operator()() {
return (GetClass()->*fn)();
}
};
template <typename T, typename C, typename R> MemFn<T,R> makeFunctor(T* pClass, R (C::*fn)())
{
return MemFn<T,R>(pClass, static_cast<MemFn<T,R>::FN_T>(fn));
}
|
entity.h
| Код |
#pragma once
#include <map>
#include <vector>
#include "member_fn.h"
//
// Dispatching
//
template <typename T> void *MakeVoidPtr(T t) {
return *(void**)(&t);
}
class BaseTrait;
//
// BaseEntity
//
class BaseEntity {
public:
typedef BaseEntity THIS_T;
typedef BaseTrait TRAIT_T;
// pure virtual destructor
virtual ~BaseEntity() = 0 { return ; }
// dispatch call to functors, T - for using in derived classes
template <typename T, typename R> bool Dispatch(R (T::*fn)());
template <typename T, typename R, typename P1> bool Dispatch(R (T::*fn)(P1), P1);
// it's convenient for Entity and Trait fn's signatures check for compatibility, T - for using in derived classes
template <typename T, typename R> void Attach (R (T::*fn)(), MemFn<TRAIT_T,R>* functor);
template <typename T, typename R, typename P1> void Attach (R (T::*fn)(P1), MemFn<TRAIT_T,R,P1>* functor);
private:
typedef std::vector<BaseMemFn<TRAIT_T>*> FunctorList;
typedef std::map<void*, FunctorList> DispatchMap;
DispatchMap map;
void _Attach (void *fn, BaseMemFn<TRAIT_T>* functor) {
map[fn].push_back(functor);
}
};
//
// Dispatching
// Dispatch with 0 params
template <typename T, typename R>
bool BaseEntity::Dispatch(R (T::*fn)())
{
static_cast<THIS_T*>((T*)0);
DispatchMap::const_iterator iter = map.find(MakeVoidPtr(fn));
if (iter == map.end()) return false;
const FunctorList& fnList = iter->second;
for (unsigned i = 0; i < fnList.size(); i++) {
//fnList[i] points to MemFn<TRAIT_T,R> it is guaranted by Attach func
(*static_cast<MemFn<TRAIT_T,R>*>(fnList[i]))();
}
return true;
}
// Dispatch with 1 param
template <typename T, typename R, typename P1>
bool BaseEntity::Dispatch(R (T::*fn)(P1), P1 p1)
{
static_cast<THIS_T*>((T*)0);
DispatchMap::const_iterator iter = map.find(MakeVoidPtr(fn));
if (iter == map.end()) return false;
const FunctorList& fnList = iter->second;
for (unsigned i = 0; i < fnList.size(); i++) {
//fnList[i] points to MemFn<TRAIT_T,R,P1> it is guaranted by Attach func
(*static_cast<MemFn<TRAIT_T,R,P1>*>(fnList[i]))(p1);
}
return true;
}
//
// Attaching
// Attach with 0 params
template <typename T, typename R>
void BaseEntity::Attach(R (T::*fn)(), MemFn<TRAIT_T,R>* functor)
{
static_cast<THIS_T*>((T*)0);
_Attach(MakeVoidPtr(fn), functor);
}
// Attach with 1 param
template <typename T, typename R, typename P1>
void BaseEntity::Attach (R (T::*fn)(P1), MemFn<TRAIT_T,R,P1>* functor)
{
static_cast<THIS_T*>((T*)0);
_Attach(MakeVoidPtr(fn), functor);
}
|
trait.h
| Код |
#pragma once
class BaseEntity;
class BaseTrait {
public:
~BaseTrait() { return; }
virtual void AttachTo(BaseEntity *pEntity) = 0 { pOwner = pEntity; }
BaseEntity* GetOwner(void) const { return pOwner; }
private:
BaseEntity *pOwner;
};
// MemFn<BaseTrait> functor with 1 param
template <typename C, typename R, typename P1> MemFn<BaseTrait,R,P1>* makeTraitFn(BaseTrait* pClass, R (C::*fn)(P1))
{
return new MemFn<BaseTrait,R,P1>(makeFunctor(pClass, fn));
}
// MemFn<BaseTrait> functor with 0 params
template <typename C, typename R> MemFn<BaseTrait,R>* makeTraitFn(BaseTrait* pClass, R (C::*fn)())
{
return new MemFn<BaseTrait,R>(makeFunctor(pClass, fn));
}
|
В принципе, можно обойтись без динамического выделения памяти в makeTraitFn.
Это была первая версия  . Думаю, можно заюзать что-нибудь из boost'а, но я пока только начал его изучать. Хотя уже впечатлился набором полезностей, которые часто приходилось самому реализовывать.
|
