ProcessorFactory.h

// ProcessorFactory.h:
// -------------------
//

#ifndef __IPSDKBASEPROCESSING_PROCESSORFACTORY_H__
#define __IPSDKBASEPROCESSING_PROCESSORFACTORY_H__

// suppression warnings
// warning C4275: non dll-interface class 'boost::noncopyable_::noncopyable' used as base for dll-interface class 'ipsdk::processor::ProcessorFactory'
// warning C4251: 'ipsdk::processor::ProcessorFactory::_factoryMap' : class 'std::map<_Kty,_Ty>' needs to have dll-interface to be used by clients of class 'ipsdk::processor::ProcessorFactory'
#pragma warning (push)
#pragma warning (disable : 4275 4251)

#include <IPSDKBaseProcessing/IPSDKBaseProcessingExports.h>
#include <IPSDKBaseProcessing/Processor/ProcessorTypes.h>
#include <IPSDKUtil/BaseTypes.h>
#include <boost/noncopyable.hpp>
#include <map>
#include <set>

namespace ipsdk {
namespace processor {


class IPSDKBASEPROCESSING_API ProcessorFactory : public boost::noncopyable
{
public:
    static ProcessorFactory&    getInstance();

protected:
    ProcessorFactory();
    ~ProcessorFactory();

// methods
public:
    bool                            isRegistredProcessor(const std::string& className) const;

    std::set<std::string>           getRegistredProcessors() const;

    template <typename ProcessorType>
    void                            registerProcessor();

    template <typename ProcessorType>
    void                            unRegisterProcessor();

    const std::string&              getProcessorName(const std::string& className) const;

    const std::string&              getProcessorToolTip(const std::string& className) const;

    const std::string&              getProcessorLibraryName(const std::string& className) const;

    const boost::filesystem::path&  getProcessorHeaderPath(const std::string& className) const;

    ProcessorPtr                    createProcessor(const std::string& className) const;

protected:
    struct ProcessorInfo
    {
        std::string             _processorName;

        std::string             _processorToolTip;

        std::string             _processorLibraryName;

        boost::filesystem::path _processorHeaderPath;

        ProcessorCreator        _processorCreator;
    };

    void                registerProcessor(const std::string& className,
                                          const ProcessorInfo& processorInfo);

    void                unRegisterProcessor(const std::string& className);

// attributes
protected:
    typedef std::map<std::string, ProcessorInfo> FactoryMap;

    FactoryMap          _factoryMap;
};


template <typename ProcessorType>
inline void
ProcessorFactory::registerProcessor()
{
    // retrieve processor class name
    const std::string& className = ProcessorType::getTypeName();

    // create an processor information structure
    ProcessorInfo processorInfo;
    processorInfo._processorName = ProcessorType::getObjectNameStr();
    processorInfo._processorToolTip = ProcessorType::getToolTipStr();
    processorInfo._processorLibraryName = ProcessorType::getLibraryNameStr();
    processorInfo._processorHeaderPath = ProcessorType::getHeaderPathStr();
    processorInfo._processorCreator = &ProcessorType::createBaseProcessor;

    // register processor into collection
    registerProcessor(className, processorInfo);
}

template <typename ProcessorType>
inline void
ProcessorFactory::unRegisterProcessor()
{
    // retrieve processor class name
    const std::string& className = ProcessorType::getTypeName();

    // register processor into collection
    unRegisterProcessor(className);
}


} // end of namespace processor
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKBASEPROCESSING_PROCESSORFACTORY_H__