FactoryT.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2010 RobotCub Consortium, European Commission FP6 Project IST-004370
 * author:  Arjan Gijsberts
 * email:   arjan.gijsberts@iit.it
 * website: www.robotcub.org
 * Permission is granted to copy, distribute, and/or modify this program
 * under the terms of the GNU General Public License, version 2 or any
 * later version published by the Free Software Foundation.
 *
 * A copy of the license can be found at
 * http://www.robotcub.org/icub/license/gpl.txt
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details
 */
 
#ifndef LM_FACTORY_TEMPLATE__
#define LM_FACTORY_TEMPLATE__
 
#include <map>
#include <vector>
#include <string>
#include <cassert>
#include <stdexcept>
#include <sstream>
 
namespace iCub {
namespace learningmachine {
 
template<class K, class T>
class FactoryT {
private:
    std::map<K, T*> map;
 
    FactoryT() { }
 
    FactoryT(const FactoryT<K, T>& other);
 
    virtual ~FactoryT() {
        for(typename std::map<K, T* >::iterator it = this->map.begin(); it != this->map.end(); it++) {
            delete it->second;
        }
    }
 
    FactoryT<K, T>& operator=(const FactoryT<K, T>& other);
 
public:
    static FactoryT<K, T>& instance() {
        static FactoryT<K, T> instance;
        return instance;
    }
 
    void registerPrototype(T* prototype) {
        assert(prototype != (T*) 0);
 
        if(prototype->getName() == "") {
            throw std::runtime_error("Cannot register prototype with empty key; please specify a unique key.");
        }
 
        if(this->map.count(prototype->getName()) > 0) {
            std::ostringstream buffer;
            buffer << "Prototype '" << prototype->getName()
                   << "' has already been registered; please specify a unique key.";
            throw std::runtime_error(buffer.str());
        }
 
        this->map[prototype->getName()] = prototype;
    }
 
 
    T* create(const K& key) {
        if(this->map.count(key) == 0) {
            std::ostringstream buffer;
            buffer << "Could not find prototype '" << key
                   << "'; please specify a valid key.";
            throw std::runtime_error(buffer.str());
        }
 
        return this->map.find(key)->second->clone();
    }
 
    std::vector<K> getKeys() {
        std::vector<K> v;
        for(typename std::map<K,T*>::iterator it = this->map.begin(); it != this->map.end(); ++it) {
            v.push_back(it->first);
        }
        return v;
    }
};
 
} // learningmachine
} // iCub
 
#endif