Repository.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of the RSB project.
 *
 * Copyright (C) 2011 by Johannes Wienke <jwienke 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 <stdexcept>
#include <set>
#include <iomanip>

#include <boost/format.hpp>

#include <rsc/runtime/Printable.h>
#include <rsc/runtime/TypeStringTools.h>
#include <rsc/runtime/NoSuchObject.h>
#include <rsc/logging/Logger.h>

#include "Converter.h"
#include "ConverterSelectionStrategy.h"
#include "UnambiguousConverterMap.h"
#include "rsb/rsbexports.h"

namespace rsb {
namespace converter {

template<class WireType>
class Repository: public rsc::runtime::Printable {
public:
    typedef typename Converter<WireType>::Ptr ConverterPtr;

    typedef std::pair<std::string, std::string> ConverterSignature;

    typedef std::map<std::string, std::string> ConverterSelectionMap;

    Repository() :
            logger(rsc::logging::Logger::getLogger("rsb.converter.Repository")) {
    }

    typename ConverterSelectionStrategy<WireType>::Ptr getConvertersForSerialization(
            const ConverterSelectionMap& selection =
                    ConverterSelectionMap()) const {
        RSCDEBUG(this->logger, "Building unambiguous map for serialization with selection "
                 << selection);

        boost::shared_ptr< UnambiguousConverterMap<WireType> >
            result(new UnambiguousConverterMap<WireType>());
        for (typename ConverterMap::const_iterator it =
                this->converters.begin(); it != this->converters.end(); ++it) {
            std::string wireSchema = it->first.first;
            std::string dataType = it->first.second;
            RSCTRACE(this->logger, "Considering converter " << it->second);

            // The data-type is not mentioned in the explicit
            // selection. Try to add the converter. This may throw in
            // case of ambiguity.
            if (selection.find(dataType) == selection.end()) {
                RSCTRACE(this->logger, "No explicit selection for data-type "
                         << dataType);
                try {
                    result->addConverter(dataType, it->second);
                } catch (const std::invalid_argument& e) {
                    std::set<std::string> wireSchemas;
                    for (typename ConverterMap::const_iterator it_ =
                            this->converters.begin();
                            it_ != this->converters.end(); ++it_) {
                        if (dataType == it_->first.second)
                            wireSchemas.insert(it_->first.first);
                    }
                    throw std::runtime_error(
                            boost::str(
                                    boost::format(
                                            "Ambiguous converter set for wire-type `%1%' and data-type `%2%': candidate wire-schemas are %3%; hint: add a configuration option `transport.<name>.converter.cpp.<one of %3%> = %2%' to resolve the ambiguity (%4%).")
                                            % rsc::runtime::typeName<WireType>()
                                    % dataType % wireSchemas % e.what()));
                }
            }
            // There is an entry for data-type in the explicit
            // selection. Add the converter if the wire-schema matches.
            else if (wireSchema == selection.find(dataType)->second) {
                RSCDEBUG(this->logger, "Explicit selection "
                         << *selection.find(dataType)
                         << " chooses data wire-schema " << wireSchema
                         << "; adding the converter");
                result->addConverter(dataType, it->second);
            } else {
                RSCDEBUG(this->logger, "Explicit selection "
                         << *selection.find(dataType)
                         << " chooses wire-schema "
                         << selection.find(dataType)->second
                         << " (not " << wireSchema
                         << "); not adding the converter");
            }
        }
        return result;
    }

    typename ConverterSelectionStrategy<WireType>::Ptr getConvertersForDeserialization(
            const ConverterSelectionMap& selection =
                    ConverterSelectionMap()) const {
        RSCDEBUG(this->logger, "Building unambiguous map for deserialization with selection "
                 << selection);

        boost::shared_ptr< UnambiguousConverterMap<WireType> >
            result(new UnambiguousConverterMap<WireType>());
        for (typename ConverterMap::const_iterator it =
                this->converters.begin(); it != this->converters.end(); ++it) {
            std::string wireSchema = it->first.first;
            std::string dataType = it->first.second;
            RSCTRACE(this->logger, "Considering converter " << it->second);

            // The wire-schema is not mentioned in the explicit
            // selection. Try to add the converter. This may throw in
            // case of ambiguity.
            if (selection.find(wireSchema) == selection.end()) {
                RSCTRACE(this->logger, "No explicit selection for wire-schema "
                         << wireSchema);
                try {
                    result->addConverter(wireSchema, it->second);
                } catch (const std::invalid_argument& e) {
                    std::set<std::string> dataTypes;
                    for (typename ConverterMap::const_iterator it_ =
                            this->converters.begin();
                            it_ != this->converters.end(); ++it_) {
                        if (wireSchema == it_->first.first)
                            dataTypes.insert(it_->first.second);
                    }
                    throw std::runtime_error(
                        boost::str(
                            boost::format(
                                "Ambiguous converter set for wire-type `%1%' and wire-schema `%2%': candidate data-types are %3%; hint: add a configuration option `transport.<name>.converter.cpp.\"%2%\" = <one of %3%>' to resolve the ambiguity (%4%).")
                            % rsc::runtime::typeName<WireType>()
                            % wireSchema % dataTypes % e.what()));
                }
            }
            // There is an entry for wire-schema in the explicit
            // selection. Add the converter if the data-type matches.
            else if (dataType == selection.find(wireSchema)->second) {
                RSCDEBUG(this->logger, "Explicit selection "
                         << *selection.find(wireSchema)
                         << " chooses data-type " << dataType
                         << "; adding the converter");
                result->addConverter(wireSchema, it->second);
            } else {
                RSCDEBUG(this->logger, "Explicit selection "
                         << *selection.find(wireSchema)
                         << " chooses data-type "
                         << selection.find(wireSchema)->second
                         << " (not " << dataType
                         << "); not adding the converter");
            }
        }
        return result;
    }

    void registerConverter(ConverterPtr converter, bool replace = false) {
        RSCINFO(this->logger, "Registering converter " << converter);

        std::string wireSchema = converter->getWireSchema();
        std::string dataType = converter->getDataType();
        if (this->converters.find(std::make_pair(wireSchema, dataType))
            != this->converters.end()
            && !replace) {
            // TODO use RSB exception; but do we have one for invalid argument?
            throw std::invalid_argument(
                    boost::str(
                            boost::format(
                                    "There already is a converter for wire-schema `%1%' and data-type `%2%'")
                                    % wireSchema % dataType));
        }
        this->converters[std::make_pair(wireSchema, dataType)] = converter;
    }

    ConverterPtr getConverter(const std::string& wireSchema,
            const std::string& dataType) const {
        typename ConverterMap::const_iterator it = this->converters.find(
                std::make_pair(wireSchema, dataType));
        if (it == this->converters.end()) {
            throw rsc::runtime::NoSuchObject(
                    boost::str(
                            boost::format(
                                    "Could not find a converter for wire-schema `%1%' and data-type `%2%'")
                                    % wireSchema % dataType));
        }
        return it->second;
    }

    ConverterPtr getConverter(const ConverterSignature& signature) const {
        return getConverter(signature.first, signature.second);
    }

    void clear() {
        this->converters.clear();
    }

    typedef boost::shared_ptr<Repository<WireType> > Ptr;

private:
    typedef std::map<ConverterSignature, ConverterPtr> ConverterMap;

    rsc::logging::LoggerPtr logger;
    ConverterMap converters;

    std::string getClassName() const {
        return "Repository<" + rsc::runtime::typeName<WireType>() + ">";
    }

    void printContents(std::ostream& stream) const {
        stream << std::endl;
        for (typename ConverterMap::const_iterator it =
                this->converters.begin(); it != this->converters.end(); ++it) {
            stream << "\t" << std::setw(16) << std::left << it->first.first
                   << " <-> " << std::setw(16) << std::left << it->first.second
                   << std::endl
                   << "\t\t" << *it->second << std::endl;
        }
    }
};



class RSB_EXPORT RepositoryCreater {
public:
    virtual ~RepositoryCreater();

    virtual void* create() = 0;
};

RSB_EXPORT void* converterRepositoryByName(const std::string &wireTypeName,
        RepositoryCreater &creater);

template<class WireType>
class TypeBasedRepositoryCreater: public RepositoryCreater {
public:
    virtual ~TypeBasedRepositoryCreater() {
    }
    void* create() {
        return new Repository<WireType> ;
    }
};


template<class WireType>
typename Repository<WireType>::Ptr converterRepository() {
    static TypeBasedRepositoryCreater<WireType> creater;
    return typename Repository<WireType>::Ptr(
            (Repository<WireType>*) converterRepositoryByName(
                    rsc::runtime::typeName<WireType>(), creater),
            rsc::misc::NullDeleter());
}

DEPRECATED(RSB_EXPORT Repository<std::string>::Ptr stringConverterRepository());

}
}