Re: How to force overloaded call in derived classes?
First of all thanks for your patience and good pointers
for Visitor and Curiously Recurring Template patterns last time :)
Now another problem of mine.
THE CODE
#include <iostream>
#include <vector>
struct CMessage;
struct CTextMessage;
struct CServerMessage;
struct CMessageInterface;
struct CMessage;
class CMessageProcessor
{
public:
virtual void ProcessMessage(CMessage& m) { std::cout << "Processing
any
message" << std::endl; };
// virtual void ProcessMessage(CTextMessage& a) { std::cout <<
"Processing CTextMessage" << std::endl; }; // (1)
// virtual void ProcessMessage(CServerMessage& c) { std::cout <<
"Processing CServerMessage" << std::endl; };
};
class CAnotherProcessor: public virtual CMessageProcessor
{
public:
virtual void ProcessMessage(CTextMessage& a) { std::cout <<
"Processing
CTextMessage in Another" << std::endl; };
};
class CDerivedProcessor: public CAnotherProcessor
{
public:
virtual void ProcessMessage(CTextMessage& a) { std::cout <<
"Processing
CTextMessage in Derived" << std::endl; };
};
struct CMessage
{
virtual void Process(CMessageProcessor& p) = 0;
virtual ~CMessage() {};
};
template<typename Self>
struct CMessageBase: public CMessage
{
virtual void Process(CMessageProcessor& p) {
p.ProcessMessage(*static_cast<Self*>(this)); }; // (2)
};
struct CMessage: public CMessageBase<CMessage>
{
};
struct CTextMessage: public CMessageBase<CTextMessage>
{
};
struct CServerMessage: public CMessageBase<CServerMessage>
{
};
int main()
{
CDerivedProcessor p;
CAnotherProcessor ap;
CMessageProcessor* pP = &p;
CMessageProcessor* pAP = ≈
std::vector<CMessage*> v;
v.push_back(new CMessage());
v.push_back(new CTextMessage());
v.push_back(new CServerMessage());
for (int i = 0; i < 3; ++i)
{
CMessage& rMsg = *v.at(i);
rMsg.Process(*pP); // (3)
rMsg.Process(*pAP);
//v.at(i)->Process(*pP);
//v.at(i)->Process(*pAP);
}
while (!v.empty())
{
delete v.back();
v.pop_back();
}
return 0;
};
THE PROBLEM
An overloaded ProcessMessage() for CTextMessage in CAnotherProcessor and
CDerivedProcessor is called only when appropriate ProcessMessage is
defined in CMessageProcessor.
Seems obvious since at (3) the virtual function (1) of that definition
is unknown and virtuality doesn't play.
However I missed this since from the beginning I've used
CMessageProcessor with all these functions uncommented.
THE QUESTION
How can I make it that at (3) the call of (2) is done to the function I
want?
Ie: when rMsg at (3) is really CTextMessage and
CDerivedProcessor::ProcessMessage(CTextMessage) is called
instead of CMessageProcessor::ProcessMessage(CMessage)?
THE NEED
I would like to have several custom message processors that are
able to process custom messages only by defining an overloaded
ProcessMessage(CCustomMessageType) and calling Process() on
CCustomMessageType it will call appropriate ProcessMessage regardles
of what is defined in CMessageProcessor.
So: extending a CCustomProcessor to process new message types
should require only defining a new ProcessMessage(CCustomMessageType)
- at least this is what I would like to have.
I'm not sure I understand your problem correctly, but probably you
need Multimethod pattern. C++ does not support multimethods directly,
but you can use metaprogramming to implement sort of multimethod.
Look at this code:
#include <iostream>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/sort.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
using namespace std;
using namespace boost;
using namespace boost::mpl;
///////////////////////////////////
// Messages //
///////////////////////////////////
struct Message
{
virtual ~Message() {}
};
struct MessageA : Message {};
struct MessageB : Message {};
typedef vector<Message, MessageA, MessageB> Messages;
///////////////////////////////////
// Processors //
///////////////////////////////////
struct Processor
{
virtual ~Processor() {}
void Process(const Message &) const
{
cout << "Message" << endl;
}
};
struct FooProcessor : Processor
{
using Processor::Process;
void Process(const MessageA &) const
{
cout << "MessageA" << endl;
}
};
struct BarProcessor : FooProcessor
{
using FooProcessor::Process;
void Process(const MessageB &) const
{
cout << "MessageB" << endl;
}
};
typedef vector<Processor, FooProcessor, BarProcessor> Processors;
///////////////////////////////////
// Multimethod //
///////////////////////////////////
typedef not_<is_base_and_derived<_1, _2> > Pred;
typedef sort<Processors, Pred>::type SortedProcessors;
typedef sort<Messages, Pred>::type SortedMessages;
struct Done {};
template <class Proc>
struct MsgFun
{
MsgFun(const Proc & proc, const Message & msg) :
proc_(proc), msg_(msg) {}
template <class T>
void operator()(identity<T>) const
{
if (const T * p = dynamic_cast<const T *>(&msg_))
{
proc_.Process(*p);
throw Done();
}
}
private:
const Proc & proc_;
const Message & msg_;
};
struct ProcFun
{
ProcFun(const Processor & proc, const Message & msg) :
proc_(proc), msg_(msg) {}
template <class T>
void operator()(identity<T>) const
{
if (const T * p = dynamic_cast<const T *>(&proc_))
for_each<
SortedMessages,
make_identity<_>
>(MsgFun<T>(*p, msg_));
}
private:
const Processor & proc_;
const Message & msg_;
};
void Process(const Processor & proc, const Message & msg)
{
try
{
for_each<SortedProcessors, make_identity<_> >(ProcFun(proc,
msg));
throw runtime_error
("You forgot to register message or processor class");
}
catch (Done)
{
}
}
int main()
{
const Message & a = MessageA();
const Message & b = MessageB();
Processor & foo = FooProcessor();
Processor & bar = BarProcessor();
Process(foo, a); // FooProcessor::Process(MessageA)
Process(foo, b); // Processor::Process(Message)
Process(bar, a); // BarProcessor::Process(MessageA)
Process(bar, b); // BarProcessor::Process(MessageB)
}
If you want to add another processor, then you should do
the following:
1. Add new processor class, which should inherit from existing
processor.
2. Add using declaration for Process method to your class.
3. Add overloads of Process method for any events you want.
4. Add your class to Processors vector. This is the main
weakness of this implementation.
Adding new message class is straightforward: add new class which
derives existing message and add your class to Messages vector.
void Process(const Processor & proc, const Message & msg) is the
multimethod -- it calls appropriate method of processor which
depends on types of both arguments. This is where
metaprogramming comes in handy.
Roman Perepelitsa.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]