drwnFactory.h

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnFactory.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <cassert>
#include <map>
#include <list>
#include <typeinfo>

#include "drwnXMLParser.h"
#include "drwnInterfaces.h"
#include "drwnLogger.h"

using namespace std;

// drwnFactoryTraits -------------------------------------------------------

template <typename T>
struct drwnFactoryTraits {
    static void staticRegistration() { /* do nothing */ };
};

// drwnFactory --------------------------------------------------------------

template<typename U>
class drwnFactory
{
 protected:
    bool _initialized;
    typedef U* (*drwnCreatorFcn)(void);
    map<string, drwnCreatorFcn> _registry;

 public:
    ~drwnFactory() { /* do nothing */ }
    static drwnFactory<U>& get();

    void registerClass(const char *name, drwnCreatorFcn fcn);
    void unregisterClass(const char *name);
    list<string> getRegisteredClasses() const;

    U *create(const char *name) const;
    U *createFromXML(drwnXMLNode& xml) const;
    U *createFromFile(const char *filename) const;

    void dump() const;

 protected:
    drwnFactory() : _initialized(false) { /* do nothing */ }
};

// drwnFactoryAutoRegister --------------------------------------------------

template<typename U, typename T>
class drwnFactoryAutoRegister
{
 public:
    drwnFactoryAutoRegister(const char *name) {
        drwnFactory<U>::get().registerClass(name, &drwnFactoryAutoRegister<U, T>::creator);
    }

 private:
    static U *creator() { return new T(); }
};

#define DRWN_FACTORY_REGISTER(baseName, className) \
    drwnFactoryAutoRegister<baseName, className> \
        __ ## baseName ## _ ## className ## _ ## AutoRegister(#className);

// drwnFactory implementation ------------------------------------------------

template<typename U>
drwnFactory<U>& drwnFactory<U>::get()
{
    static drwnFactory<U> factory;
    if (!factory._initialized) {
        DRWN_LOG_DEBUG("initializing drwnFactory for " << typeid(U).name());
        factory._initialized = true;
        drwnFactoryTraits<U>::staticRegistration();
    }
    return factory;
}

template<typename U>
void drwnFactory<U>::registerClass(const char *name, drwnCreatorFcn fcn)
{
    DRWN_ASSERT(name != NULL);

    typename map<string, drwnCreatorFcn>::iterator jt = _registry.find(string(name));
    if (jt != _registry.end()) {
        DRWN_LOG_ERROR("class \"" << name << "\" already registered with drwnFactory");
        jt->second = fcn;
    } else {
        DRWN_LOG_DEBUG("registering class \"" << name << "\" with the drwnFactory");
        _registry.insert(make_pair(string(name), fcn));
    }
}

template<typename U>
void drwnFactory<U>::unregisterClass(const char *name)
{
    DRWN_ASSERT(name != NULL);
    DRWN_LOG_DEBUG("unregistering class \"" << name << "\" from drwnFactory");
    typename map<string, drwnCreatorFcn>::iterator jt = _registry.find(string(name));
    if (jt == _registry.end()) {
        DRWN_LOG_ERROR("class \"" << name << "\" does not exist in drwnFactory");
        return;
    }

    _registry.erase(jt);
}

template<typename U>
list<string> drwnFactory<U>::getRegisteredClasses() const
{
    list<string> names;
    for (typename map<string, drwnCreatorFcn>::const_iterator it = _registry.begin();
         it != _registry.end(); ++it) {
        names.push_back(it->first);
    }
    return names;
}

template<typename U>
U *drwnFactory<U>::create(const char *name) const
{
    DRWN_ASSERT(name != NULL);

    typename map<string, drwnCreatorFcn>::const_iterator jt = _registry.find(string(name));
    if (jt == _registry.end()) {
        DRWN_LOG_ERROR("class \"" << name << "\" does not exist in drwnFactory");
        return NULL;
    }

    return (*jt->second)();
}

template<typename U>
U *drwnFactory<U>::createFromXML(drwnXMLNode& xml) const
{
    // construct node and initialize from XML
    U *object = create(xml.name());
    if (object == NULL) {
        return NULL;
    }

    object->load(xml);
    return object;
}

template<typename U>
U *drwnFactory<U>::createFromFile(const char *filename) const
{
    DRWN_ASSERT(filename != NULL);

    // parse XML file
    drwnXMLDoc xml;
    drwnXMLNode *node = drwnParseXMLFile(xml, filename);
    DRWN_ASSERT(node != NULL);

    return createFromXML(*node);
}

template<typename U>
void drwnFactory<U>::dump() const
{
    DRWN_LOG_MESSAGE("drwnFactory has the following registered classes:");
    for (typename map<string, drwnCreatorFcn>::const_iterator it = _registry.begin();
         it != _registry.end(); ++it) {
        DRWN_LOG_MESSAGE("  " << it->first);
    }
}