ZFX + Developia

Code: Alles auswählen

// Schnittstelle
class IComponent;

// Factory
class CFactory {
public:
    // Typ eines Funktionszeigers auf eine Create-Funktion - gibt IComponent & zurück, wird als ComponentCreationFunction angesprochen und erwartet ein int als Parameter
    typedef IComponent & (*ComponentCreationFunction)(int);

    // Hier registrieren sich neue Komponenten-Implementierungen. Könnte private sein mit Friendship oder so, deine Entscheidung.
    void RegisterComponent(
        string ItsName,
        ComponentCreationFunction ItsCreationFunction
    ) {
        MyMap.insert(ItsName, ItsCreationFunction);
    }

    // Die Factory-Funktion. Interessante Frage: const oder nicht? Verändert sich der logische Zustand einer Fabrik, wenn sie etwas produziert hat?
    IComponent & CreateComponent(
        string ItsName,
        int ItsDummyParameter
    ) {
        if(MapIterator const ToComponent = MyMap.find(ItsName) != MyMap.end()) // Variablendeklaration in if – äußerst nützlich
            return (*ToComponent->second)(ItsDummyParameter); // ruft die hinterlegte Funktion auf und gibt ihr Ergebnis zurück
        else
            throw Blubb;
    }

}; // class CFactory


// Eine Implementierung
class CComponentA : public IComponent {
    ...
private:
    // Die Factory-Funktion dieser Implementierung
    static // darf natürlich kein this erwarten, sonst wird es auch mit den Funktionszeigern schwieriger
    CComponentA & Create(
        int DummyParameter
    ) {
        return *(new CComponentA(DummyParameter));
    }

public:

    // Konstruktor.
    explicit // weil er nur einen Parameter hat
    CComponentA(
        int DummyParameter // nur dazu da, damit du siehst, wie man mit Funktionszeigern und Parametern umgeht, falls du das brauchst
    ) … }

    // Trägt diese Klasse in der gegebenen Factory ein. Deine Entscheidung, wann und wo und wie.
    static // an keine Instanz gebunden
    void RegisterAt(
        CFactory & Factory
    ) {
        Factory.AddComponent("A", &Create); // Funktionszeiger hinterlegen – unnütze Information:
                                            // Das & vor Create kannst du auch weglassen. Falls die Zielfunktion ein Template ist, solltest du das sogar, weil
                                            // der Visual C++-Compiler einen Bug innehat und Template-Funktionszeiger nicht optimiert, wenn man ein & davor schreibt.
    }

}; // class CComponentA

Code: Alles auswählen

template <
    typename CComponent
> IComponent & Create(
    int DummyParameter
) {
    return *(new CComponent(DummyParameter));
}

Factory.RegisterComponent("A", &Create<CComponentA>);

Code: Alles auswählen

#include <map>

template <class tClass> tClass* FactoryWorker()
{
	return new tClass();
}

template<class tBaseClass, typename tKey> class Factory
{
public:
	tBaseClass* Create(tKey Key)
	{
		return m_Workers[Key]();
	}
	void Register(tKey Key, BLA)
	{
		m_Workers.insert(Key, BLA);
	}
private:
	map <tKey, BLA> m_Workers;
};

Factory.Register("ClassA", &FactoryWorker<ClassA>);
ClassA* p=Factory.Create("ClassA");

Code: Alles auswählen

// Typ eines Funktionszeigers auf eine Create-Funktion - gibt tBaseClass * zurück, wird als ComponentCreationFunction angesprochen und erwartet keine Parameter
typedef tBaseClass * (*ComponentCreationFunction)();

Code: Alles auswählen

        void Register(tKey Key, ComponentCreationFunction Function)
        {
                m_Workers.insert(Key, Function);
        }

Code: Alles auswählen

        map <tKey, ComponentCreationFunction> m_Workers;

Code: Alles auswählen

///Factory with 1 arguments
template<class tBaseClass, typename tKey, typename t0> class Factory1
{
public:
	typedef tBaseClass* (*WorkerFun)(t0 v0);
	typedef std::map<tKey, WorkerFun> tMap;


	///Register a new class
	void Register(tKey Key, WorkerFun Fun)
	{ 
		tMap::iterator It=m_Workers.find(Key);
		if(It!=m_Workers.end())
		{
			stringstream s;
			s << Key << " is already registered";
			BOOST_THROW_EXCEPTION(std::exception(s.str().c_str()));
		}
		else
			m_Workers.insert(pair<tKey, WorkerFun>(Key, Fun));
	}

	///This functions builds the object for you
	tBaseClass* Create(tKey Key, t0 v0)
	{ 
		tMap::iterator It=m_Workers.find(Key);
		if(It==m_Workers.end())
			BOOST_THROW_EXCEPTION(std::exception(CreateNotFoundMessage(Key).c_str()));
		else
			return It->second(v0);
	}

	///This is a intern function to create the actual object
	template <class tClass> static tBaseClass* Worker(t0 v0)
	{ return new tClass(v0); }

private:
	tMap m_Workers;

	std::string CreateNotFoundMessage(tKey Key)
	{
		std::stringstream s;
		s << "Couldn't find Class " << Key << "\n"
			<< "Registered classes are: ";

		pair<tKey, WorkerFun> P;
		bool a=false;//we only want ", " between the elements
		foreach(P, m_Workers)
		{
			if(a)
				s << ", ";
			s << P.first;
			a=true;
		}

		return s.str();
	}
};


//Benutzung:
Factory1<WorldObject, string, SceneManager*> m_ObjectFactory;
m_ObjectFactory.Register("Lumberjack", m_ObjectFactory.Worker<WorldObject>);
WorldObject* NewHouse=m_ObjectFactory.Create("Lumberjackl", &m_SceneManager);