ExtensionPoint.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 "fwRuntime/BundleElement.hpp"
#include "fwRuntime/config.hpp"
#include "fwRuntime/Extension.hpp"
#include "fwRuntime/Runtime.hpp"

#include <fwCore/base.hpp>

#include <boost/filesystem/path.hpp>

#include <algorithm>
#include <iostream>
#include <string>

namespace fwRuntime
{
struct Bundle;

namespace io
{
struct BundleDescriptorReader;
struct Validator;
}
}

namespace fwRuntime
{

struct ExtensionPoint : public BundleElement
{
    friend struct ::fwRuntime::io::BundleDescriptorReader;

    typedef Extension::Container ConfigurationElementContainer;

    const ConfigurationElementContainer getAllConfigurationElements() const
    {
        typedef std::back_insert_iterator< ConfigurationElementContainer >  Inserter;

        ConfigurationElementContainer container;
        Inserter inserter(container);

        getAllConfigurationElements<Inserter>( inserter );

        return container;
    }

    template<typename OutputIterator>
    void getAllConfigurationElements( OutputIterator& output ) const
    {
        // Retrieves all connected extensions.
        typedef std::vector< std::shared_ptr< Extension > > ExtensionContainer;
        typedef std::back_insert_iterator< ExtensionContainer > Inserter;

        ExtensionContainer extensions;
        Inserter inserter(extensions);

        getAllExtensions( inserter );

        // Walk through the collected extensions to extract configuration elements.
        for( ExtensionContainer::const_iterator i = extensions.begin(); i != extensions.end(); ++i )
        {
            std::shared_ptr< Extension >   extension( *i );
            if ( extension->isEnable() )
            {
                std::copy( extension->begin(), extension->end(), output);
            }
            OSLM_DEBUG_IF("getAllConfigurationElements for point=" <<  extension->getPoint() <<
                          " extension" << extension->getIdentifier() << "extension disabled", !extension->isEnable());
        }
    }

    template<typename OutputIterator>
    void getAllExtensions( OutputIterator& output ) const
    {
        Runtime* rntm( Runtime::getDefault() );

        for( Runtime::ExtensionIterator i = rntm->extensionsBegin(); i != rntm->extensionsEnd(); ++i )
        {
            std::shared_ptr< Extension >   extension( *i );
            if( extension->getPoint() == m_id && extension->isEnable() == true
                && extension->validate() == Extension::Valid
                )
            {
                *output = extension;
                ++output;
            }
        }
    }

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

    FWRUNTIME_API std::shared_ptr< io::Validator > getExtensionValidator() const;

    protected:

        ExtensionPoint(
            const std::shared_ptr<Bundle>       bundle,
            const std::string&              id,
            const boost::filesystem::path&  schema);

    private:

        const std::string m_id;                                     
                                                                    // identifier
        const ::boost::filesystem::path m_schema;                   
                                                                    // contributed extensions
        mutable std::shared_ptr< io::Validator >    m_validator;

        void operator=(const ExtensionPoint&) noexcept;

};

} // namespace fwRuntime