Re: Mapping operations to codes
On Aug 23, 5:17 pm, "Default User" <defaultuse...@yahoo.com> wrote:
I'm not sure how well that subject captured the topic. Anyway, this is a
branching from my previous topic "Fun with member-function pointers".
The general problem is that we have a number of "drivers" for instrume=
nts.
These are essentially an abstraction layer than translates control messag=
es
from higher-level modules into something the particular hardware can
understand. The API for this is a system of operation codes and an
associated data word that has bits set or cleared for various options.
My current solution is to map the op codes to pointers to member function=
s
that handle the particular operation. There's also a requirement that eac=
h
driver be able to respond with a list of the supported op codes. The prob=
lem
is that it results in a lot of very similar code in each driver. I had
wanted to push down as much behavior as possible to the base class. My
initial thoughts (see other thread) look like they result in undefined
behavior, so no good.
Below is a small representation of the problem. It's not the real code
(which would be very large), so it's not necessary to suggest improvement=
s
in layout or that sort of thing. Thoughts on attacking the general proble=
m
would be welcome.
Brian
================= code ======
============
#include <iostream>
#include <map>
#define CALL_HANDLER(object,ptrToMember)((object).*(ptrToMember))
class tbase
{
public:
protected:
tbase()
{
}
virtual ~tbase()
{
}
};
class test : public tbase
{
public:
typedef int (test::*HandlerPtr)(int);
test() // sets up the map of handlers to op codes
{
handlers[0] = &test::H0;
handlers[4] = &test::H4;
}
virtual ~tbase()
{
}
virtual int H0(int data)
{
std::cout << "test::H0: " << data << "\n";
return data;
}
Why is the above virtual? just a mistake?
int H4(int data)
{
std::cout << "test::H4: " << data << "\n";
return data;
}
void write(int data, int code) // finds the handler and passes dat=
a
{
std::map<int, HandlerPtr>::iterator it;
it = handlers.find(code);
It maybe worth while implementing this as a switch case block and do
away with the map altogether, you'd only need one function pointer.
switch(code){
case(123)
fnctptr = &test::H0;
break;
case(456)
fnctptr = &test::H4;
break;
default //catch errors;
}
this->*fnctptr(data);
It may look like more code, if there are alot of "op codes", but the
compiler may optimise this to be faster than a map search.
Are the "op codes" a pre defined set of integers?
If so what range etc?
if (it != handlers.end())
{
// Found, call the function pointer
CALL_HANDLER(*this, it->second)(data);
I dunno why you have a macro in there.
}
else // unhandled code
{
// error handling
}
}
void list() // just prints supported op codes
{
std::map<int, HandlerPtr>::iterator it = handlers.begin();
std::cout << "Supported Op codes:\n";
while (it != handlers.end())
{
std::cout << it->first << "\n";
it++;
}
I think the above could probably be more efficient but again need to
know the details of the "op codes" before thinking about it. For
example you could just store a string containing all the ops codes,
and print it out.
}
private:
std::map<int, HandlerPtr> handlers;
};
int main()
{
test t;
t.list();
t.write(123, 0);
t.write(456, 4);
return 0;
You also want to think about copying and assignments?
If you have only one set of pre-defined "op-codes" you don't really
want to be copying that map across multiple objects.
I think alot of this depends on these "op codes", Are they a
predefined set?
HTH