Re: design opinions requested
On Jun 3, 2:22 pm, "Daniel T." <danie...@earthlink.net> wrote:
Tim H <thoc...@gmail.com> wrote:
Most of the time Stuff will be handled in one of two patterns.
for each item in stuff.big_list {
if item is_foo()
handle_foo()
else if item is_bar()
handle_bar()
else
handle_bat()
}
or
for each item in stuff.big_list {
if item is_foo()
handle_foo
}
The above looks like two perfect candidates for polymorphism.
To make matters more complicated, there are actually three different
Stuff containers, and each can hold a subset of the total things. For
example a Stuff container can hold Foo, Bar, or Bat. A Junk container
can hold Bar or Bat, but not Foo. A Mess container can hold Foo or
Bat, but not bar.
So you might end up with several different contexts in which to use
"stuff". Each context should be a pure virtual class. Foo, Bar and Bat
will all derive from StuffContext. Bar, and Bat will derive from
JunkContext. Foo and Bat will derive from MessContext.
class StuffContext {
public:
virtual void handleStuff() = 0;
};
class Stuff {
typedef vector< pair< string, StuffContext* > > Container;
Container stuff;
public:
void handle() {
for ( Container::iterator it = stuff.begin();
it != stuff.end();
++it )
{
it->second->handleStuff();
}
}
};
Two problems with this. First, handle_stuff() is up to the caller.
Sometimes they just want to print a Foo, sometimes they want to do
other things with it. I can't predict nor wrap that. Removing the
base class method, I arrive at something similar to my #1. The second
problem is that this exports policy (what can/can't be contained) from
the container into the containee.
I know I am being a bit difficult, I'm just trying to work through all
the pros and cons :)
Thanks
Tim