Runtime.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWRUNTIME_RUNTIME_HPP__
#define __FWRUNTIME_RUNTIME_HPP__

#include "fwRuntime/config.hpp"
#include "fwRuntime/RuntimeException.hpp"
#include "fwRuntime/Version.hpp"

#include <boost/filesystem/path.hpp>

#include <set>
#include <vector>

namespace fwRuntime
{
struct Bundle;
struct ConfigurationElement;
struct Extension;
struct ExtensionPoint;
struct IExecutable;
struct ExecutableFactory;
struct IPlugin;
}

namespace fwRuntime
{

struct Runtime
{
    typedef std::set< std::shared_ptr<Bundle> >     BundleContainer;

    typedef BundleContainer::iterator BundleIterator;
    typedef std::set< std::shared_ptr<Extension> >  ExtensionContainer;
    typedef ExtensionContainer::iterator ExtensionIterator;

    FWRUNTIME_API static Runtime* getDefault();

    ~Runtime();

    FWRUNTIME_API void setWorkingPath(const ::boost::filesystem::path& workingPath);

    FWRUNTIME_API ::boost::filesystem::path getWorkingPath() const;

    FWRUNTIME_API void addBundle( std::shared_ptr< Bundle > bundle );

    FWRUNTIME_API void unregisterBundle( std::shared_ptr< Bundle > bundle );

    FWRUNTIME_API void addBundles( const ::boost::filesystem::path& repository );

    FWRUNTIME_API void addDefaultBundles();

    FWRUNTIME_API BundleIterator bundlesBegin();

    FWRUNTIME_API BundleIterator bundlesEnd();

    FWRUNTIME_API std::shared_ptr< Bundle > findBundle( const std::string& identifier,
                                                        const Version& version = Version() ) const;

    FWRUNTIME_API std::shared_ptr< Bundle > findEnabledBundle( const std::string& identifier,
                                                               const Version& version = Version() ) const;


    FWRUNTIME_API void addExecutableFactory( std::shared_ptr< ExecutableFactory > factory );

    FWRUNTIME_API void unregisterExecutableFactory( std::shared_ptr< ExecutableFactory > factory );

    FWRUNTIME_API IExecutable* createExecutableInstance( const std::string& type );

    FWRUNTIME_API IExecutable* createExecutableInstance( const std::string& type,
                                                         std::shared_ptr< ConfigurationElement > configurationElement );

    FWRUNTIME_API std::shared_ptr< ExecutableFactory > findExecutableFactory( const std::string& type ) const;

    FWRUNTIME_API std::shared_ptr< IPlugin > getPlugin( const std::shared_ptr< Bundle > bundle ) const;


    FWRUNTIME_API void addExtension( std::shared_ptr<Extension> extension);

    FWRUNTIME_API void unregisterExtension( std::shared_ptr<Extension> extension);

    FWRUNTIME_API ExtensionIterator extensionsBegin();

    FWRUNTIME_API ExtensionIterator extensionsEnd();

    FWRUNTIME_API std::shared_ptr< Extension > findExtension( const std::string& identifier ) const;


    FWRUNTIME_API void addExtensionPoint( std::shared_ptr<ExtensionPoint> point);

    FWRUNTIME_API void unregisterExtensionPoint( std::shared_ptr<ExtensionPoint> point);

    FWRUNTIME_API std::shared_ptr< ExtensionPoint > findExtensionPoint( const std::string& identifier ) const;

    private:

        typedef std::set< std::shared_ptr< ExecutableFactory > > ExecutableFactoryContainer;

        typedef std::set< std::shared_ptr<ExtensionPoint> > ExtensionPointContainer;

        typedef std::vector< std::shared_ptr<IPlugin> > PluginContainer;

        static std::shared_ptr<Runtime> m_instance; 

        ExecutableFactoryContainer m_executableFactories; 
        ExtensionContainer m_extensions;                  
        ExtensionPointContainer m_extensionPoints;        
        BundleContainer m_bundles;                        
        PluginContainer m_plugins;                        

        ::boost::filesystem::path m_workingPath; 

        Runtime();
};

} // namespace fwRuntime

#endif // __FWRUNTIME_RUNTIME_HPP__