Factory.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of the RSB project
 *
 * Copyright (C) 2010 by Sebastian Wrede <swrede at techfak dot uni-bielefeld dot de>
 *
 * This file may be licensed under the terms of the
 * GNU Lesser General Public License Version 3 (the ``LGPL''),
 * or (at your option) any later version.
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the LGPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the LGPL along with this
 * program. If not, go to http://www.gnu.org/licenses/lgpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The development of this software was supported by:
 *   CoR-Lab, Research Institute for Cognition and Robotics
 *     Bielefeld University
 *
 * ============================================================ */

#pragma once

#include <string>
#include <vector>
#include <map>

#include <rsc/logging/Logger.h>
#include <rsc/logging/LoggerFactory.h>
#include <rsc/misc/langutils.h>
#include <rsc/runtime/NoSuchObject.h>
#include <rsc/runtime/TypeStringTools.h>
#include <rsc/runtime/Printable.h>
#include <rsc/patterns/Factory.h>

#include <boost/type_traits.hpp>

#include "InPullConnector.h"
#include "InPushConnector.h"
#include "OutConnector.h"
#include "rsb/rsbexports.h"

namespace rsb {
namespace transport {

template <typename Interface>
class ConnectorFactory;

typedef ConnectorFactory<InPullConnector> InPullFactory;

typedef ConnectorFactory<InPushConnector> InPushFactory;

typedef ConnectorFactory<OutConnector> OutFactory;

RSB_EXPORT InPullFactory& getInPullFactory();
RSB_EXPORT InPushFactory& getInPushFactory();
RSB_EXPORT OutFactory& getOutFactory();

template <typename Interface>
class ConnectorFactory: public rsc::patterns::Factory<std::string, Interface>,
                        public rsc::runtime::Printable {
public:

    class ConnectorInfo: public rsc::runtime::Printable {
    public:
        typedef std::set<std::string> SchemaList;
        typedef std::set<std::string> OptionList;

        ConnectorInfo(const std::string& name,
                      const SchemaList& schemas,
                      bool remote,
                      const OptionList& options) :
            name(name), schemas(schemas), remote(remote), options(options) {
            this->options.insert("enabled");
        }

        std::string getName() const {
            return this->name;
        }

        SchemaList getSchemas() const {
            return this->schemas;
        }

        OptionList getOptions() const {
            return this->options;
        }

        bool isRemote() const {
            return this->remote;
        }

        bool operator<(const ConnectorInfo& other) const {
            if (this->name < other.name) {
                return true;
            } else if (this->name == other.name) {
                if (this->schemas < other.schemas) {
                    return true;
                } else if (this->schemas == other.schemas) {
                    if (this->remote < other.remote) {
                        return true;
                    } else if (this->remote == other.remote) {
                        return this->options < other.options;
                    }
                }
            }
            return false;
        }
    private:
        std::string name;
        SchemaList schemas;
        bool remote;
        OptionList options;

        void printContents(std::ostream& stream) const {
            stream << this->name
                   << ", schemas = " << this->schemas
                   << ", remote = " << this->remote
                   << ", options = " << this->options;
        }
    };

private:
    rsc::logging::LoggerPtr logger;

    friend InPullFactory& getInPullFactory();
    friend InPushFactory& getInPushFactory();
    friend OutFactory& getOutFactory();

    typedef rsc::patterns::Factory<std::string, Interface> Factory;
    typedef typename Factory::CreateFunction CreateFunction;
    typedef typename Factory::ImplMapProxy ImplMapProxy;
    typedef std::map<std::string, ConnectorInfo> InfoMap; // forward
public:
    ConnectorFactory() :
        logger(rsc::logging::Logger::getLogger("rsb.transport.ConnectorFactory<" + rsc::runtime::typeName<Interface>() + ">")) {
    }

    ConnectorInfo getConnectorInfo(const std::string& name) const {
        typename InfoMap::const_iterator it = this->infos.find(name);
        if (it == this->infos.end()) {
            throw rsc::runtime::NoSuchObject(name);
        }
        return it->second;
    }

    std::set<ConnectorInfo> getConnectorInfos() const {
        std::set<ConnectorInfo> result;

        for (typename InfoMap::const_iterator it = this->infos.begin();
             it != this->infos.end(); ++it) {
            result.insert(it->second);
        }
        return result;
    }

    void registerConnector(const std::string& name,
            const CreateFunction& constructor,
            const std::set<std::string>& schemas = std::set<std::string>(),
            bool remote = true,
            const std::set<std::string>& options = std::set<std::string>()) {
        RSCINFO(this->logger, "Registering connector "
                << name
                << " for schemas " << schemas);

        Factory::impls().register_(name, constructor);

        ConnectorInfo info(name, schemas, remote, options);
        this->infos.insert(std::make_pair(name, info));
    }

    void registerConnector(const std::string& name,
            const CreateFunction& constructor, const std::string& schema,
            bool remote = true,
            const std::set<std::string>& options = std::set<std::string>()) {
        std::set<std::string> schemas;
        schemas.insert(schema);
        registerConnector(name, constructor, schemas, remote, options);
    }
private:
    InfoMap infos;

    void printContents(std::ostream& stream) const {
        const ImplMapProxy& implementations = Factory::impls();
        stream << std::endl;
        for (typename ImplMapProxy::const_iterator it = implementations.begin(); it
                 != implementations.end(); ++it) {
            stream << "\t" << getConnectorInfo(it->first) << std::endl;
        }
    }
};

}
}