factory.cpp

/***************************************************************************
 *   Copyright (C) 2008 by Tomassino Ferrauto                              *
 *   t_ferrauto@yahoo.it                                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   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.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "factory.h"
#include <QStringList>

namespace farsa {

Factory& Factory::getInstance()
{
    // The meyer singleton
    static Factory factory;

    return factory;
}

ConfigurationParameters& Factory::getTypeDescriptions() {
    static ConfigurationParameters typeDescriptions(true);
    return typeDescriptions;
}

Factory::Factory() :
    m_classMap(),
    m_parentsMap(),
    m_childrenMap()
{
}

Factory::~Factory()
{
    // Deleting all creators
    for(QMap<QString, ParameterSettableCreator*>::iterator i = m_classMap.begin(); i != m_classMap.end(); i++) {
        delete i.value();
        i.value() = NULL;
    }
}

QStringList Factory::getAllSubclasses(QString className, int levelToStop, bool noAbstractClasses)
{
    QStringList subclasses;
    QStringList currents;
    currents.append(className);
    int level = 0;
    while (((level < levelToStop) || (levelToStop == -1)) && (currents.count() > 0)) {
        QStringList subs;
        foreach (QString current, currents) {
            subs.append(m_childrenMap[current]);
        }
        subclasses.append(subs);
        currents = subs;
        level++;
    }
    if (noAbstractClasses) {
        // filter QStringList
        QStringList filtered;
        foreach (QString current, subclasses) {
            if (isAbstract(current)) continue;
            filtered << current;
        }
        return filtered;
    }
    return subclasses;
}

bool Factory::isAbstract(QString className)
{
    // if there is no creator, then it is abstract
    return !(m_classMap.contains(className));
}

ConfigurationWidget* Factory::getEditorForType(ConfigurationParameters& params, QString prefix, QWidget* parent, Qt::WindowFlags f)
{
    const QString typeForGroup = params.getValue(prefix + ConfigurationParameters::GroupSeparator() + "type");

    // Creating the configuration widget. If we have a specific editor for the type creating it,
    // otherwise returing the default widget
    if ((!typeForGroup.isEmpty()) && (m_editorsMap.contains(typeForGroup))) {
        return m_editorsMap[typeForGroup]->create(params, prefix, parent, f);
    }
    return NULL;
}

void Factory::cleanupMapsForReRegistration(QString className)
{
    // Need to check whether className was already registered to clean up things. We check m_parentsMap
    // because in the previous registration the class could have been an abstract class
    if (m_parentsMap.contains(className)) {
        // Removing the old creator if it exists
        if (m_classMap.contains(className)) {
            delete m_classMap[className];
        }

        // Also removing the class from the list of children of its parent class
        if (m_childrenMap.contains(m_parentsMap[className])) {
            const int nRemoved = m_childrenMap[m_parentsMap[className]].removeAll(className);
            Q_ASSERT_X((nRemoved <= 1), "Registering a class", ("More that one instance of " + className + " were present").toLatin1().data());
        }

        // The class being re-registered could be a parent of other classes: as we don't know what
        // happened to that relations, we leave them as they are
    }
}

} // end namespace farsa