I need a simple object serialization, where loading an object from
file looks like this:
Foo* foo1 = FooFactory::create("./saved/foo1.a321f23d");
Foo* foo2 = FooFactory::create("./saved/foo2.eb287ac8");
Now, Foo is an abstract base class, and FooFactory contains a static
function which again calls static create functions on Foo1 or Foo2
(see code for all classes below). The problem is that all these
functions are static, but I also want them to be part of the (virtual)
Foo interface. But virtual static functions are not allowed.
You might say that Foo1::create(...) should not be a member function,
but just a global function outside of Foo1. But I want classes derived
from Foo1 to be able to inherit or override create(...).
How should I design this properly?
Thanks! Markus
<code>
class Foo {
public:
// virtual static std::string type() const = 0; // not
allowed
// virtual static Foo* create(const std::string& dataLocation) =
0; // not allowed
// other functions that constiute the Foo
interface
};
class Foo1 : public Foo {
public:
static std::string type() {
static const std::string t = "Foo1";
return t;
}
static Foo* create(const std::string& dataLocation) {
return new Foo1(/* parameters according to data read from
dataLocation*/);
}
};
class Foo2 : public Foo1 {
public:
static std::string type() {
static const std::string t = "Foo2";
return t;
}
// function "create" is derived from
Foo1
};
namespace FooFactory {
Foo* create(const std::string& dataLocation) {
const std::string type =
getType(dataLocation);
if(type == Foo1::type()){
return Foo1::create(dataLocation);
}
else if(type == Foo2::type()){
return Foo2::create(dataLocation);
}
}
} // end namespace
</code>
