design guidance .. I'm confused

[ma740988]

I've provided a stripped down version - as best I could - to get us by.
That said, I'm in a quandry with respect to a design here.

Consider:
// stream.h
#ifndef STREAM_H
#define STREAM_H

# pragma warning (disable : 4786) // if using microsofts compiler ver6

# include <iostream>
# include <string>
# include <map>
# include <typeinfo>

using namespace std;

struct stream
{
string classId;
string buffer;
size_t curPos;

stream(string clsId)
: classId(clsId), curPos(0)
{}

stream(char* buf, size_t size)
: curPos(0)
{
string temp(buf, size);
size_t pos = temp.find(':');
if (pos == string::npos || pos == 0 || pos == size-1)
return;
classId = temp.substr(0, pos);
buffer = temp.substr(pos +1);
}

bool isValid() { return curPos <= buffer.length() ; }
operator bool() { return isValid(); }

size_t getBufferSize() {
return isValid()? classId.size() + 1 + buffer.size() : 0;
}

size_t getBuffer(char* & buf, size_t siz)
{
size_t sizNeeded = getBufferSize() ;
return sizNeeded;
}
};
template <class T>
inline stream& operator>>(stre am& ds, T& t) {
// stuff
return ds;
}
template <class T>
inline stream& operator<<(stre am& ds, T& t) {
// stuff
return ds;
}
// more
#endif

// factory.h
#ifndef FACTORY_H
#define FACTORY_H

# include<map>
# include<string>
# include "stream.h"

class factory;
typedef factory* (*CreateInstanc eFunc)();
struct stream;
using namespace std;
class factory
{
// factory map is mapping class names to create functions
static std::map<std::s tring, CreateInstanceF unc> factoryMap;
public:
virtual std::string getClassId() = 0;
virtual bool load(stream& ds) = 0;
virtual bool store(stream& ds) = 0;
virtual void execute() = 0;
static factory* createInstance( const stream& ds)
{
map<string, CreateInstanceF unc>::iterator it;
if ((it = factoryMap.find (ds.classId)) == factoryMap.end( ))
return NULL;
return (it->second)();
}

static bool registerClass(
const std::string& className,
CreateInstanceF unc createFunc
)
{
map<string, CreateInstanceF unc>::iterator it;
if ((it = factoryMap.find (className)) != factoryMap.end( ))
return false; // already registered

factoryMap[className] = createFunc;
return true;
}

stream* store();
};

std::map<string , CreateInstanceF unc> factory::factor yMap;

#endif

// now we're ready file: test.cpp
# include <iostream>
# include <string>
# include "factory.h"
# include "stream.h"

using namespace std;

struct test_struct
: public factory
{
int idx;
test_struct() : idx(99) {}

std::string getClassId() {
return "test_struc t";
}
bool store(stream& ds) {
ds >> idx;
return ds.isValid();
}
bool load(stream& ds) {
ds << idx;
return ds.isValid();
}
static factory* create_msg () {
return new test_struct;
}
void execute () {
}
};

/////////////////////////////////////////////////////////////////
// the registration below is REALLY bad news. Need to rethink this
// static initilization order stuff.
//factory::regist erClass("test_s truct", test_struct::cr eate_msg);
class test {
test_struct* ptr_msg;
public:
test() : ptr_msg(0) {
factory::regist erClass("test_s truct", test_struct::cr eate_msg);
}
void get_data()
{
char buffer[4096] = { "test_struct:99 " };
size_t len = sizeof buffer / sizeof *buffer;

stream st (buffer, len);
if (st)
{
ptr_msg = (test_struct*)f actory::createI nstance(st); // 99
if (ptr_msg != NULL)
{
cout << " success " << endl;
if (ptr_msg->idx == 99)
cout << " even more success " << endl;
}
}
}
};

int main()
{
test t;
t.get_data();
}

The line marked '99' is a cast from a polymorphic type to a test_struct
object. So I thought it would nice to eliminate that ugly cast, hence
the addition of the 'execute' function in persistent.

Trouble is, the execute function creates a problem for two reasons:
1. I could modify the source in get_data to look like:

if (st)
{
//ptr_msg = (test_struct*)f actory::createI nstance(st);
factory* pfact = factory::create Instance(st);
if (pfact != NULL)
{
cout << " success " << endl;
pfact->execute();
//if (ptr_msg->idx == 99)
// cout << " even more success " << endl;
}
}
Except now I need a way to move from the factory object to a
test_struct object so that I could do:
if (ptr_msg->idx == 99)
// do a special thing.

One thought was to modify execute in the test_struc class to look like:
void execute () {
t.update(this); // call some update function in test
}

Trouble is. I now need a 'global' initilization of t. Not good. It
gets worse. In my real code, the initilization of t is wrapped in a
try catch handler so that there goes the global initilization.

2. In theory my 'struct's are defined as incoming and outging msg
structs. So now:

struct outgoing_msg
: public factory
{};

struct incoming_msg
: public factory
{};
The only struct that needs to go through these 'hoops' is the
incoming_msg struct. That said, I would have an execute member
function in the outgoing_msg struct for NO reason.

In the end I suspect I'm just forced to live with the cast from a
polymorphic object to a test_struct.

ptr_msg = (test_struct*)f actory::createI nstance(st);

Thoughts/ideas?

Thanks in advance