Design problem: Factory pattern needs 'static virtual'?

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>