operations.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_OPERATIONS_HPP__
#define __FWRUNTIME_OPERATIONS_HPP__

#include "fwRuntime/config.hpp"
#include "fwRuntime/ConfigurationElement.hpp"
#include "fwRuntime/Executable.hpp"
#include "fwRuntime/Extension.hpp"
#include "fwRuntime/ExtensionPoint.hpp"
#include "fwRuntime/Runtime.hpp"
#include "fwRuntime/RuntimeException.hpp"
#include "fwRuntime/Version.hpp"

#include <fwCore/base.hpp>

#include <boost/filesystem/path.hpp>

#include <iterator>
#include <memory>
#include <string>

namespace fwRuntime
{
struct Bundle;

namespace profile
{
class Profile;
}
}

namespace fwRuntime
{

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

template<typename T>
T* createExecutableInstance(
    const std::shared_ptr<Extension>    extension,
    const std::string& element = "executable",
    const std::string& attribute = "class" )
{
    // Retrieves the right configuration element.
    std::shared_ptr<ConfigurationElement> elt( extension->findConfigurationElement(element) );
    if( elt == 0 )
    {
        throw RuntimeException(element + ": configuration element not found in extension.");
    }

    // Creates the executable instance from the found configuration element.
    return createExecutableInstance<T>( elt, attribute );
}

template<typename T>
T* createExecutableInstance(
    const std::shared_ptr<ConfigurationElement> element,
    const std::string& attribute = "class" )
{

    // Retrieves the executable type.
    if( element->hasAttribute( attribute ) == false )
    {
        throw RuntimeException( "Configuration element has no attribute '" + attribute + "'." );
    }
    const std::string type( element->getExistingAttributeValue(attribute) );

    // Creates the executable instance.
    Runtime* rntm( Runtime::getDefault()                         );
    std::unique_ptr< IExecutable > executable( rntm->createExecutableInstance(type, element) );

    // Converts the executable instance to the right type.
    T* result = dynamic_cast<T*>( executable.get() );
    if( result == 0 )
    {
        throw RuntimeException( "Executable creation failed. Bad cast" );
    }
    executable.release();

    // That's all folks !
    return result;
}

template<typename OutputIterator>
void getAllExtensionsForPoint(
    const std::string& identifier,
    OutputIterator output
    )
{
    std::shared_ptr< ExtensionPoint >  point = findExtensionPoint(identifier);

    if( !point )
    {
        throw RuntimeException( identifier + ": invalid extension point identifier." );
    }
    point->getAllExtensions( output );
}

template<typename OutputIterator>
void getAllConfigurationElementsForPoint(
    const std::string& identifier,
    OutputIterator output
    )
{
    std::shared_ptr< ExtensionPoint >  point = findExtensionPoint(identifier);

    OSLM_TRACE("getAllConfigurationElementsForPoint(" << identifier << "Bundle" <<
               point->getBundle()->getIdentifier() );

    if( !point )
    {
        throw RuntimeException( identifier + ": invalid extension point identifier." );
    }

    // VAG test if ExtensionPoint is enable
    if ( point->isEnable() )
    {
        point->getAllConfigurationElements( output );
    }
    else
    {
        OSLM_DEBUG( "IGNORING getAllConfigurationElementsForPoint(" << identifier << ") extension point disabled");
    }

}

template<typename Container>
const Container getAllConfigurationElementsForPoint(const std::string& identifier)
{
    // Defines an insert iterator type for the container.
    typedef std::back_insert_iterator< Container > Inserter;

    // Collects all contributed configuratoin elements.
    Container elements;
    Inserter inserter(elements);
    getAllConfigurationElementsForPoint(identifier, inserter);

    // The job is done!
    return elements;
}

template< typename Container, typename T >
const Container getAllExecutableForPoint( const std::string& identifier,
                                          const std::string& attribute = "class" )
{
    // Defines the element container
    typedef std::vector< std::shared_ptr< ConfigurationElement > > ConfigurationElementContainer;

    // Retrieves all configuration elements.
    ConfigurationElementContainer elements( getAllConfigurationElementsForPoint< ConfigurationElementContainer >(
                                                identifier) );

    // Defines an insert iterator type for the executable container.
    typedef std::back_insert_iterator< Container > Inserter;

    // Walks through collected configuration elements and create desired executable instances
    Container result;
    ConfigurationElementContainer::iterator iElement;
    Inserter iInserter( result );
    for( iElement = elements.begin(); iElement != elements.end(); ++iElement, ++iInserter )
    {
        std::shared_ptr< ConfigurationElement >    element( *iElement );
        std::shared_ptr< T >                       executable( createExecutableInstance< T >(element, attribute) );

        iInserter = executable;
    }
    return result;
}

FWRUNTIME_API std::shared_ptr< ConfigurationElement > findConfigurationElement( const std::string& identifier,
                                                                                const std::string& pointIdentifier );

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

FWRUNTIME_API ::boost::filesystem::path getBundleResourcePath(const std::string& bundleIdentifier) noexcept;

FWRUNTIME_API ::boost::filesystem::path getBundleResourceFilePath(const std::string& bundleIdentifier,
                                                                  const ::boost::filesystem::path& path) noexcept;

FWRUNTIME_API ::boost::filesystem::path getBundleResourceFilePath(const ::boost::filesystem::path& path) noexcept;

FWRUNTIME_API ::boost::filesystem::path getLibraryResourceFilePath(const ::boost::filesystem::path& path) noexcept;

FWRUNTIME_API ::boost::filesystem::path getResourceFilePath(const ::boost::filesystem::path& path) noexcept;

FWRUNTIME_API ::boost::filesystem::path getBundleResourcePath( std::shared_ptr<Bundle> bundle,
                                                               const ::boost::filesystem::path& path) noexcept;

FWRUNTIME_API ::boost::filesystem::path getBundleResourcePath( std::shared_ptr<ConfigurationElement> element,
                                                               const ::boost::filesystem::path& path) noexcept;

FWRUNTIME_API ::boost::filesystem::path getBundleResourcePath(const IExecutable* executable,
                                                              const ::boost::filesystem::path& path) noexcept;

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

FWRUNTIME_API std::shared_ptr< ::fwRuntime::profile::Profile > startProfile( const boost::filesystem::path& path );

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

FWRUNTIME_API void startBundle(const std::string& identifier);

} // namespace fwRuntime

#endif // __FWRUNTIME_OPERATIONS_HPP__