pluginfactory.h

Go to the documentation of this file.

#ifndef MATERIALFACTORY_H
#define MATERIALFACTORY_H

#include <string>
#include <map>
#include <libxml/parser.h>
#include <libxml/xpath.h>
#include <libxml/tree.h>
#include <sigc++/sigc++.h>

#include "material.h"
#include "renderable.h"
#include "bumpmap.h"

typedef sigc::signal<Material *, std::map<std::string, std::string> > material_create_fn;

typedef sigc::signal<Renderable *, xmlNode *> primitive_create_fn;

typedef sigc::signal<BumpMap *, xmlNode *> bumpmap_create_fn;

typedef sigc::slot<Material *, std::map<std::string, std::string> > material_create_slot;

typedef sigc::slot<Renderable *, xmlNode *> primitive_create_slot;

typedef sigc::slot<BumpMap *, xmlNode *> bumpmap_create_slot;


template <class _ParentType, class _SigType, class _SlotType>
class PluginFactory {
    protected:

        std::map<std::string, _SigType>  m_createFunctions;

    public:
        _ParentType * create(std::string type, std::map<std::string, std::string> attributes) {
            if(m_createFunctions.find(type) != m_createFunctions.end()) {
                _ParentType * tmp =  m_createFunctions[type].emit(attributes);
                if(!tmp)
                    log_warn("[deprecated] Create function for %s type returned NULL.", type.c_str());
                return tmp;
            }
            
            log_warn("[deprecated] Could not find signal for %s type.", type.c_str());
            return NULL;
        }

        _ParentType * create(std::string type, xmlNode * node) {
            if(m_createFunctions.find(type) != m_createFunctions.end()) {
                _ParentType * tmp =  m_createFunctions[type].emit(node);
                if(!tmp)
                    log_warn("Create function for <%s> node returned NULL.", node->name);
                return tmp;
            }

            log_warn("Could not find signal for %s type.", type.c_str());
            return NULL;
        }

        bool registerPlugin(std::string type, _SlotType createFunction) {
            log_debug("Registering function for type <%s>.", type.c_str());
            if(m_createFunctions.find(type) != m_createFunctions.end()) {
                log_warn("Function for type <%s> already registered, ignoring.", type.c_str());
                return false;
            }

            log_debug("Adding plugin for <%s> node...", type.c_str());
            m_createFunctions[type].connect(createFunction);
            log_debug("...done");
        }

        static PluginFactory<_ParentType, _SigType, _SlotType> * get_instance() {
            static PluginFactory<_ParentType, _SigType, _SlotType> * instance;
            if(instance == NULL) {
                log_debug("Creating new factory");
                instance = new PluginFactory<_ParentType, _SigType, _SlotType>();
            }
            return instance;
        }

};

typedef PluginFactory<Material,  material_create_fn,  material_create_slot>  MaterialFactory;
typedef PluginFactory<Renderable, primitive_create_fn, primitive_create_slot> RenderableFactory;
typedef PluginFactory<BumpMap,   bumpmap_create_fn,   bumpmap_create_slot> BumpMapFactory;

#endif
/*
 * change log
 *
 * $Log$
 */

---