Bundle.hpp

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

#pragma once

#include "fwCore/base.hpp"

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

#include <boost/filesystem/path.hpp>

#include <map>
#include <set>
#include <string>

namespace fwRuntime
{
struct Extension;
struct ExtensionPoint;
struct ExtensionRegistry;
struct IExecutable;
struct ExecutableFactory;
struct IPlugin;
struct Runtime;

namespace io
{
struct BundleDescriptorReader;
}
}

namespace fwRuntime
{

struct Bundle : public std::enable_shared_from_this< Bundle >
{
    friend struct ::fwRuntime::io::BundleDescriptorReader;

    static const char s_VERSION_DELIMITER = '-';
    typedef std::set< SPTR( ExecutableFactory ) >      ExecutableFactoryContainer;     
                                                                                       // factory container type.
    typedef ExecutableFactoryContainer::const_iterator ExecutableFactoryConstIterator; 
                                                                                       // factory container constant
                                                                                       // iterator type.

    typedef std::set< SPTR( Extension ) >      ExtensionContainer;             
                                                                               // type.
    typedef ExtensionContainer::const_iterator ExtensionConstIterator;         
                                                                               // constant iterator type.

    typedef std::set< SPTR( ExtensionPoint ) >      ExtensionPointContainer;        
                                                                                    // container type.
    typedef ExtensionPointContainer::const_iterator ExtensionPointConstIterator;    
                                                                                    // container constant iterator type.

    typedef std::set< SPTR(dl::Library) >     LibraryContainer;               
                                                                              // type.
    typedef LibraryContainer::const_iterator LibraryConstIterator;            
                                                                              // constant iterator type.

    static SPTR( Bundle ) getLoadingBundle();

    FWRUNTIME_API void addLibrary( SPTR( dl::Library ) library );

    FWRUNTIME_API LibraryConstIterator librariesBegin() const;

    FWRUNTIME_API LibraryConstIterator librariesEnd() const;

    FWRUNTIME_API void addExecutableFactory( SPTR( ExecutableFactory ) factory );

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

    FWRUNTIME_API ExecutableFactoryConstIterator executableFactoriesBegin() const;

    FWRUNTIME_API ExecutableFactoryConstIterator executableFactoriesEnd() const;

    FWRUNTIME_API SPTR( ExecutableFactory ) findExecutableFactory( const std::string& type ) const;

    void addExtension( SPTR( Extension ) extension );

    FWRUNTIME_API bool hasExtension(const std::string& identifier) const;

    FWRUNTIME_API void setEnableExtension(const std::string& identifier, const bool enable);

    FWRUNTIME_API ExtensionConstIterator extensionsBegin() const;

    FWRUNTIME_API ExtensionConstIterator extensionsEnd() const;

    void addExtensionPoint( SPTR( ExtensionPoint ) extension );

    FWRUNTIME_API SPTR( ExtensionPoint ) findExtensionPoint( const std::string& identifier ) const;

    FWRUNTIME_API bool hasExtensionPoint(const std::string& identifier) const;

    FWRUNTIME_API void setEnableExtensionPoint(const std::string& identifier, const bool enable);

    FWRUNTIME_API ExtensionPointConstIterator extensionPointsBegin() const;

    FWRUNTIME_API ExtensionPointConstIterator extensionPointsEnd() const;

    FWRUNTIME_API void addRequirement( const std::string& requirement );

    FWRUNTIME_API const std::string& getIdentifier() const;

    FWRUNTIME_API const ::boost::filesystem::path& getLibraryLocation() const;

    FWRUNTIME_API const ::boost::filesystem::path& getResourcesLocation() const;

    FWRUNTIME_API const std::string getClass() const;

    FWRUNTIME_API const Version& getVersion() const;

    FWRUNTIME_API SPTR( IPlugin ) getPlugin() const;

    FWRUNTIME_API bool isEnable() const;

    FWRUNTIME_API void setEnable( const bool state );

    FWRUNTIME_API void start();

    FWRUNTIME_API void stop();

    FWRUNTIME_API void initialize();

    FWRUNTIME_API void uninitialize();

    FWRUNTIME_API void addParameter( const std::string& identifier, const std::string& value );

    FWRUNTIME_API const std::string getParameterValue( const std::string& identifier ) const;

    FWRUNTIME_API bool hasParameter( const std::string& name ) const;

    bool isStarted()
    {
        return m_started;
    }
    //------------------------------------------------------------------------------

    bool isInitialized()
    {
        return m_initialized;
    }

    FWRUNTIME_API static std::string getBundleStr(const std::string& identifier, const Version& version);

    protected:

        Bundle( const ::boost::filesystem::path& location,
                const std::string& id,
                const std::string& version );

        Bundle( const ::boost::filesystem::path& location,
                const std::string& id,
                const std::string& version,
                const std::string& pluginClass );

    private:

        typedef std::set< std::string >                 RequirementContainer;
                                                                             // type.
        typedef std::map< std::string, std::string >    ParameterContainer; 

        static SPTR( Bundle )           m_loadingBundle;    
                                                            // dynamic libaries

        ::boost::filesystem::path m_libraryLocation;        
        const ::boost::filesystem::path m_resourcesLocation;  
        const std::string m_identifier;                     
        const Version m_version;                            
        const std::string m_class;                          
        bool m_enable { false };                                      
                                                                      // not
        ExtensionContainer m_extensions;                    
        ExtensionPointContainer m_extensionPoints;          
        ExecutableFactoryContainer m_executableFactories;   
        LibraryContainer m_libraries;                       
        RequirementContainer m_requirements;                
        SPTR( IPlugin )                 m_plugin;           
        ParameterContainer m_parameters;                    

        bool m_started { false };
        bool m_initialized { false };

        void operator= (const Bundle& );

        void loadLibraries();

        void loadRequirements();

        void startPlugin();

};

} // namespace fwRuntime