DataIOManager.hpp

Go to the documentation of this file.

/* 
 * DataIOManager.hpp 
 *
 * This file is part of the Chemical Data Processing Toolkit
 *
 * Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifndef CDPL_BASE_DATAIOMANAGER_HPP
#define CDPL_BASE_DATAIOMANAGER_HPP
 
#include <algorithm>
#include <functional>
#include <vector>
#include <string>
#include <cstddef>
 
#include "CDPL/Base/APIPrefix.hpp"
#include "CDPL/Base/DataInputHandler.hpp"
#include "CDPL/Base/DataOutputHandler.hpp"
#include "CDPL/Base/DataFormat.hpp"
#include "CDPL/Base/Exceptions.hpp"
 
 
namespace CDPL
{
 
    namespace Chem
    {
 
        class Molecule;
        class MolecularGraph;
        class Reaction;
    } // namespace Chem
 
    namespace Pharm
    {
 
        class Pharmacophore;
        class FeatureContainer;
    } // namespace Pharm
 
    namespace Grid
    {
 
        template <typename T, typename CVT>
        class RegularGrid;
        template <typename T, typename CVT>
        class RegularGridSet;
    } // namespace Grid
 
    namespace Base
    {
 
        template <typename T>
        class DataIOManager
        {
 
          public:
            typedef DataInputHandler<T>  InputHandlerType;
            typedef DataOutputHandler<T> OutputHandlerType;
 
            typedef typename InputHandlerType::SharedPointer  InputHandlerPointer;
            typedef typename OutputHandlerType::SharedPointer OutputHandlerPointer;
 
          private:
            typedef std::vector<InputHandlerPointer>  InputHandlerList;
            typedef std::vector<OutputHandlerPointer> OutputHandlerList;
 
          public:
            typedef typename InputHandlerList::iterator InputHandlerIterator;
 
            typedef typename OutputHandlerList::iterator OutputHandlerIterator;
 
            static void registerInputHandler(const InputHandlerPointer& handler);
 
            static void registerOutputHandler(const OutputHandlerPointer& handler);
 
            static bool unregisterInputHandler(const DataFormat& fmt);
 
            static bool unregisterOutputHandler(const DataFormat& fmt);
 
            static bool unregisterInputHandler(const InputHandlerPointer& handler);
 
            static bool unregisterOutputHandler(const OutputHandlerPointer& handler);
 
            static void unregisterInputHandler(std::size_t idx);
 
            static void unregisterOutputHandler(std::size_t idx);
 
            static InputHandlerIterator unregisterInputHandler(const InputHandlerIterator& it);
 
            static OutputHandlerIterator unregisterOutputHandler(const OutputHandlerIterator& it);
 
            static std::size_t getNumInputHandlers();
 
            static std::size_t getNumOutputHandlers();
 
            static const InputHandlerPointer& getInputHandler(std::size_t idx);
 
            static const OutputHandlerPointer& getOutputHandler(std::size_t idx);
 
            static InputHandlerIterator getInputHandlersBegin();
 
            static InputHandlerIterator getInputHandlersEnd();
 
            static OutputHandlerIterator getOutputHandlersBegin();
 
            static OutputHandlerIterator getOutputHandlersEnd();
 
            static InputHandlerPointer getInputHandlerByFormat(const DataFormat& fmt);
 
            static InputHandlerPointer getInputHandlerByName(const std::string& name);
 
            static InputHandlerPointer getInputHandlerByFileExtension(const std::string& file_ext);
 
            static InputHandlerPointer getInputHandlerByFileName(const std::string& file_name);
 
            static InputHandlerPointer getInputHandlerByMimeType(const std::string& mime_type);
 
            static OutputHandlerPointer getOutputHandlerByFormat(const DataFormat& fmt);
 
            static OutputHandlerPointer getOutputHandlerByName(const std::string& name);
 
            static OutputHandlerPointer getOutputHandlerByFileExtension(const std::string& file_ext);
 
            static OutputHandlerPointer getOutputHandlerByFileName(const std::string& file_name);
            
            static OutputHandlerPointer getOutputHandlerByMimeType(const std::string& mime_type);
 
          private:
            DataIOManager() {}
            ~DataIOManager() {}
 
            static DataIOManager& getInstance();
 
            InputHandlerList  inputHandlers;
            OutputHandlerList outputHandlers;
        };
 
        // \cond DOC_IMPL_DETAILS
 
#ifdef _MSC_VER
# define _CDPL_BASE_API       
#else
# define _CDPL_BASE_API CDPL_BASE_API
#endif // _MSC_VER
        
        extern template class _CDPL_BASE_API DataIOManager<Chem::Molecule>;
 
        extern template class _CDPL_BASE_API DataIOManager<Chem::MolecularGraph>;
 
        extern template class _CDPL_BASE_API DataIOManager<Chem::Reaction>;
 
        extern template class _CDPL_BASE_API DataIOManager<Pharm::Pharmacophore>;
 
        extern template class _CDPL_BASE_API DataIOManager<Pharm::FeatureContainer>;
 
        extern template class _CDPL_BASE_API DataIOManager<Grid::RegularGrid<double, double> >;
 
        extern template class _CDPL_BASE_API DataIOManager<Grid::RegularGridSet<double, double> >;
 
#undef _CDPL_BASE_API
        
        // \endcond
    } // namespace Base
} // namespace CDPL
 
 
// Implementation
 
template <typename T>
CDPL::Base::DataIOManager<T>& CDPL::Base::DataIOManager<T>::getInstance()
{
    static DataIOManager<T> instance;
 
    return instance;
}
 
template <typename T>
void CDPL::Base::DataIOManager<T>::registerInputHandler(const InputHandlerPointer& handler)
{
    getInstance().inputHandlers.push_back(handler);
}
 
template <typename T>
void CDPL::Base::DataIOManager<T>::registerOutputHandler(const OutputHandlerPointer& handler)
{
    getInstance().outputHandlers.push_back(handler);
}
 
template <typename T>
bool CDPL::Base::DataIOManager<T>::unregisterInputHandler(const DataFormat& fmt)
{
    InputHandlerList& handlers = getInstance().inputHandlers;
 
    typename InputHandlerList::iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                          std::bind(std::equal_to<DataFormat>(), std::ref(fmt),
                                                                    std::bind(&DataInputHandler<T>::getDataFormat, std::placeholders::_1)));
    if (it != handlers.end()) {
        handlers.erase(it);
        return true;
    }
 
    return false;
}
 
template <typename T>
bool CDPL::Base::DataIOManager<T>::unregisterOutputHandler(const DataFormat& fmt)
{
    OutputHandlerList& handlers = getInstance().outputHandlers;
 
    typename OutputHandlerList::iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                           std::bind(std::equal_to<DataFormat>(), std::ref(fmt),
                                                                     std::bind(&DataOutputHandler<T>::getDataFormat, std::placeholders::_1)));
    if (it != handlers.end()) {
        handlers.erase(it);
        return true;
    }
 
    return false;
}
 
template <typename T>
bool CDPL::Base::DataIOManager<T>::unregisterInputHandler(const InputHandlerPointer& handler)
{
    InputHandlerList& handlers = getInstance().inputHandlers;
 
    typename InputHandlerList::iterator it = std::find(handlers.begin(), handlers.end(), handler);
 
    if (it != handlers.end()) {
        handlers.erase(it);
        return true;
    }
 
    return false;
}
 
template <typename T>
bool CDPL::Base::DataIOManager<T>::unregisterOutputHandler(const OutputHandlerPointer& handler)
{
    OutputHandlerList& handlers = getInstance().outputHandlers;
 
    typename OutputHandlerList::iterator it = std::find(handlers.begin(), handlers.end(), handler);
 
    if (it != handlers.end()) {
        handlers.erase(it);
        return true;
    }
 
    return false;
}
 
template <typename T>
void CDPL::Base::DataIOManager<T>::unregisterInputHandler(std::size_t idx)
{
    InputHandlerList& handlers = getInstance().inputHandlers;
 
    if (idx >= handlers.size())
        throw IndexError("DataIOManager: handler index out of bounds");
 
    handlers.erase(handlers.begin() + idx);
}
 
template <typename T>
void CDPL::Base::DataIOManager<T>::unregisterOutputHandler(std::size_t idx)
{
    using namespace std::placeholders;
 
    OutputHandlerList& handlers = getInstance().outputHandlers;
 
    if (idx >= handlers.size())
        throw IndexError("DataIOManager: handler index out of bounds");
 
    handlers.erase(handlers.begin() + idx);
}
 
template <typename T>
typename CDPL::Base::DataIOManager<T>::InputHandlerIterator
CDPL::Base::DataIOManager<T>::unregisterInputHandler(const InputHandlerIterator& it)
{
    InputHandlerList& handlers = getInstance().inputHandlers;
 
    if (it < handlers.begin() || it >= handlers.end())
        throw RangeError("DataIOManager: input-handler iterator out of valid range");
 
    return handlers.erase(it);
}
 
template <typename T>
typename CDPL::Base::DataIOManager<T>::OutputHandlerIterator
CDPL::Base::DataIOManager<T>::unregisterOutputHandler(const OutputHandlerIterator& it)
{
    OutputHandlerList& handlers = getInstance().outputHandlers;
 
    if (it < handlers.begin() || it >= handlers.end())
        throw RangeError("DataIOManager: output-handler iterator out of valid range");
 
    return handlers.erase(it);
}
 
template <typename T>
std::size_t CDPL::Base::DataIOManager<T>::getNumInputHandlers()
{
    return getInstance().inputHandlers.size();
}
 
template <typename T>
std::size_t CDPL::Base::DataIOManager<T>::getNumOutputHandlers()
{
    return getInstance().outputHandlers.size();
}
 
template <typename T>
const typename CDPL::Base::DataInputHandler<T>::SharedPointer& CDPL::Base::DataIOManager<T>::getInputHandler(std::size_t idx)
{
    const InputHandlerList& handlers = getInstance().inputHandlers;
 
    if (idx >= handlers.size())
        throw IndexError("DataIOManager: handler index out of bounds");
 
    return handlers[idx];
}
 
template <typename T>
const typename CDPL::Base::DataOutputHandler<T>::SharedPointer& CDPL::Base::DataIOManager<T>::getOutputHandler(std::size_t idx)
{
    const OutputHandlerList& handlers = getInstance().outputHandlers;
 
    if (idx >= handlers.size())
        throw IndexError("DataIOManager: handler index out of bounds");
 
    return handlers[idx];
}
 
template <typename T>
typename CDPL::Base::DataIOManager<T>::InputHandlerIterator CDPL::Base::DataIOManager<T>::getInputHandlersBegin()
{
    return getInstance().inputHandlers.begin();
}
 
template <typename T>
typename CDPL::Base::DataIOManager<T>::InputHandlerIterator CDPL::Base::DataIOManager<T>::getInputHandlersEnd()
{
    return getInstance().inputHandlers.end();
}
 
template <typename T>
typename CDPL::Base::DataIOManager<T>::OutputHandlerIterator CDPL::Base::DataIOManager<T>::getOutputHandlersBegin()
{
    return getInstance().outputHandlers.begin();
}
 
template <typename T>
typename CDPL::Base::DataIOManager<T>::OutputHandlerIterator CDPL::Base::DataIOManager<T>::getOutputHandlersEnd()
{
    return getInstance().outputHandlers.end();
}
 
template <typename T>
typename CDPL::Base::DataInputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getInputHandlerByFormat(const DataFormat& fmt)
{
    const InputHandlerList& handlers = getInstance().inputHandlers;
 
    typename InputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                std::bind(std::equal_to<DataFormat>(), std::ref(fmt),
                                                                          std::bind(&DataInputHandler<T>::getDataFormat, std::placeholders::_1)));
    return (it == handlers.end() ? InputHandlerPointer() : *it);
}
 
template <typename T>
typename CDPL::Base::DataInputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getInputHandlerByFileExtension(const std::string& file_ext)
{
    const InputHandlerList& handlers = getInstance().inputHandlers;
 
    typename InputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                std::bind(&DataFormat::matchesFileExtension,
                                                                          std::bind(&DataInputHandler<T>::getDataFormat, std::placeholders::_1),
                                                                          std::ref(file_ext)));
    return (it == handlers.end() ? InputHandlerPointer() : *it);
}
 
template <typename T>
typename CDPL::Base::DataInputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getInputHandlerByFileName(const std::string& file_name)
{
    auto& handlers = getInstance().inputHandlers;
    std::string file_ext;
 
    for (std::string::size_type i = file_name.find_first_of('.', 0); i != std::string::npos; i = file_name.find_first_of('.', i)) {
        file_ext = file_name.substr(++i);
 
        auto it = std::find_if(handlers.begin(), handlers.end(), [&](const InputHandlerPointer& handler) {
            return handler->getDataFormat().matchesFileExtension(file_ext);
        });
 
        if (it != handlers.end())
            return *it;
    }
 
    return InputHandlerPointer();
}
 
template <typename T>
typename CDPL::Base::DataInputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getInputHandlerByName(const std::string& name)
{
    const InputHandlerList& handlers = getInstance().inputHandlers;
 
    typename InputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                std::bind(&DataFormat::matchesName,
                                                                          std::bind(&DataInputHandler<T>::getDataFormat, std::placeholders::_1),
                                                                          std::ref(name)));
    return (it == handlers.end() ? InputHandlerPointer() : *it);
}
 
template <typename T>
typename CDPL::Base::DataInputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getInputHandlerByMimeType(const std::string& mime_type)
{
    const InputHandlerList& handlers = getInstance().inputHandlers;
 
    typename InputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                std::bind(&DataFormat::matchesMimeType,
                                                                          std::bind(&DataInputHandler<T>::getDataFormat, std::placeholders::_1),
                                                                          std::ref(mime_type)));
    return (it == handlers.end() ? InputHandlerPointer() : *it);
}
 
template <typename T>
typename CDPL::Base::DataOutputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getOutputHandlerByFormat(const DataFormat& fmt)
{
    const OutputHandlerList& handlers = getInstance().outputHandlers;
 
    typename OutputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                 std::bind(std::equal_to<DataFormat>(), std::ref(fmt),
                                                                           std::bind(&DataOutputHandler<T>::getDataFormat, std::placeholders::_1)));
    return (it == handlers.end() ? OutputHandlerPointer() : *it);
}
 
template <typename T>
typename CDPL::Base::DataOutputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getOutputHandlerByName(const std::string& name)
{
    const OutputHandlerList& handlers = getInstance().outputHandlers;
 
    typename OutputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                 std::bind(&DataFormat::matchesName,
                                                                           std::bind(&DataOutputHandler<T>::getDataFormat, std::placeholders::_1),
                                                                           std::ref(name)));
    return (it == handlers.end() ? OutputHandlerPointer() : *it);
}
 
template <typename T>
typename CDPL::Base::DataOutputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getOutputHandlerByFileExtension(const std::string& file_ext)
{
    const OutputHandlerList& handlers = getInstance().outputHandlers;
 
    typename OutputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                 std::bind(&DataFormat::matchesFileExtension,
                                                                           std::bind(&DataOutputHandler<T>::getDataFormat, std::placeholders::_1),
                                                                           std::ref(file_ext)));
    return (it == handlers.end() ? OutputHandlerPointer() : *it);
}
 
template <typename T>
typename CDPL::Base::DataOutputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getOutputHandlerByFileName(const std::string& file_name)
{
    auto& handlers = getInstance().outputHandlers;
    std::string file_ext;
 
    for (std::string::size_type i = file_name.find_first_of('.', 0); i != std::string::npos; i = file_name.find_first_of('.', i)) {
        file_ext = file_name.substr(++i);
 
        auto it = std::find_if(handlers.begin(), handlers.end(), [&](const OutputHandlerPointer& handler) {
            return handler->getDataFormat().matchesFileExtension(file_ext);
        });
 
        if (it != handlers.end())
            return *it;
    }
 
    return OutputHandlerPointer();
}
 
template <typename T>
typename CDPL::Base::DataOutputHandler<T>::SharedPointer CDPL::Base::DataIOManager<T>::getOutputHandlerByMimeType(const std::string& mime_type)
{
    const OutputHandlerList& handlers = getInstance().outputHandlers;
 
    typename OutputHandlerList::const_iterator it = std::find_if(handlers.begin(), handlers.end(),
                                                                 std::bind(&DataFormat::matchesMimeType,
                                                                           std::bind(&DataOutputHandler<T>::getDataFormat, std::placeholders::_1),
                                                                           std::ref(mime_type)));
    return (it == handlers.end() ? OutputHandlerPointer() : *it);
}
 
#endif // CDPL_BASE_DATAIOMANAGER_HPP