IService.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 "fwServices/config.hpp"
#include "fwServices/factory/new.hpp"
#include "fwServices/helper/ProxyConnections.hpp"

#include <fwCom/helper/SigSlotConnection.hpp>
#include <fwCom/HasSignals.hpp>
#include <fwCom/HasSlots.hpp>
#include <fwCom/Slot.hpp>
#include <fwCom/Slots.hpp>

#include <fwData/Object.hpp>

#include <fwRuntime/ConfigurationElement.hpp>

#include <fwTools/Failed.hpp>
#include <fwTools/Object.hpp>

#include <boost/property_tree/ptree.hpp>

#include <cstdint>

namespace fwServices
{
namespace registry
{
class ObjectService;
}
namespace fwThread
{
class Worker;
}

#define KEY_GROUP_NAME(key, index) (key + "#" + std::to_string(index) )

class FWSERVICES_CLASS_API IService : public ::fwTools::Object,
                                      public ::fwCom::HasSlots,
                                      public ::fwCom::HasSignals
{

// to give to OSR an access on IService.m_associatedObject;
friend class registry::ObjectService;
friend class AppConfigManager;

public:
    fwCoreServiceClassDefinitionsMacro( (IService)(::fwTools::Object) );
    fwCoreAllowSharedFromThis();

    typedef ::boost::property_tree::ptree ConfigType;

    typedef std::string IdType;
    typedef std::string KeyType;
    typedef std::map< KeyType, CWPTR( ::fwData::Object )> InputMapType;
    typedef std::map< KeyType, WPTR( ::fwData::Object )> InOutMapType;
    typedef std::map< KeyType, SPTR( ::fwData::Object )> OutputMapType;

    enum class AccessType : std::uint8_t
    {
        INPUT,
        OUTPUT,
        INOUT,
    };

    struct ObjectServiceConfig
    {
        std::string m_uid;
        std::string m_key;
        AccessType m_access;
        bool m_autoConnect { false };
        bool m_optional { false };
    };

    struct Config
    {
        std::string m_uid;
        std::string m_type;
        bool m_globalAutoConnect { false };
        std::string m_worker;
        std::vector<ObjectServiceConfig> m_objects;
        std::map<std::string, size_t> m_groupSize;
        CSPTR(::fwRuntime::ConfigurationElement) m_config;
    };

    FWSERVICES_API static const std::string s_DEFAULT_OBJECT;


    typedef enum
    {
        STARTED,    
        STARTING,   
        SWAPPING,   
        STOPPED,    
        STOPPING    
    } GlobalStatus;

    typedef enum
    {
        UPDATING,   
        NOTUPDATING 
    } UpdatingStatus;

    typedef enum
    {
        CONFIGURING,    
        CONFIGURED,     
        UNCONFIGURED    
    } ConfigurationStatus;


    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_STARTED_SIG;
    typedef ::fwCom::Signal<void ()> StartedSignalType;

    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_UPDATED_SIG;
    typedef ::fwCom::Signal<void ()> UpdatedSignalType;

    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_STOPPED_SIG;
    typedef ::fwCom::Signal<void ()> StoppedSignalType;


    typedef std::shared_future< void > SharedFutureType;
    typedef std::packaged_task< void ()> PackagedTaskType;
    typedef std::future< void > UniqueFutureType;

    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_START_SLOT;
    typedef ::fwCom::Slot<SharedFutureType()> StartSlotType;

    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_STOP_SLOT;
    typedef ::fwCom::Slot<SharedFutureType()> StopSlotType;

    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_UPDATE_SLOT;
    typedef ::fwCom::Slot<SharedFutureType()> UpdateSlotType;

    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_SWAP_SLOT;
    typedef ::fwCom::Slot<SharedFutureType(::fwData::Object::sptr)> SwapSlotType;

    FWSERVICES_API static const ::fwCom::Slots::SlotKeyType s_SWAPKEY_SLOT;
    typedef ::fwCom::Slot<SharedFutureType(const KeyType&, ::fwData::Object::sptr)> SwapKeySlotType;

    FWSERVICES_API void setWorker( SPTR(::fwThread::Worker) worker );

    FWSERVICES_API SPTR(::fwThread::Worker) getWorker() const;



    FWSERVICES_API void setConfiguration( const ::fwRuntime::ConfigurationElement::sptr _cfgElement );

    FWSERVICES_API void setConfiguration( const Config& _configuration);

    FWSERVICES_API void setConfiguration( const ConfigType& ptree );

    FWSERVICES_API void configure();

    FWSERVICES_API SharedFutureType start();

    FWSERVICES_API SharedFutureType stop();

    FWSERVICES_API SharedFutureType update();

    FWSERVICES_API SharedFutureType swap( ::fwData::Object::sptr _obj );

    FWSERVICES_API SharedFutureType swapKey( const KeyType& _key, ::fwData::Object::sptr _obj );


    FWSERVICES_API GlobalStatus getStatus() const noexcept;

    FWSERVICES_API bool isStarted() const noexcept;

    FWSERVICES_API bool isStopped() const noexcept;

    FWSERVICES_API ConfigurationStatus getConfigurationStatus() const noexcept;

    FWSERVICES_API UpdatingStatus getUpdatingStatus() const noexcept;


    FWSERVICES_API ::fwRuntime::ConfigurationElement::sptr getConfiguration() const;

    FWSERVICES_API ConfigType getConfigTree() const;


    FWSERVICES_API ::fwData::Object::sptr getObject();

    template< class DATATYPE > SPTR(DATATYPE) getObject();

    FWSERVICES_API const InputMapType& getInputs() const;

    FWSERVICES_API const InOutMapType& getInOuts() const;

    FWSERVICES_API const OutputMapType& getOutputs() const;

    FWSERVICES_API std::vector< ::fwData::Object::csptr > getObjects() const;

    template< class DATATYPE > CSPTR(DATATYPE) getInput(const KeyType& key) const;

    template< class DATATYPE > SPTR(DATATYPE) getInOut(const KeyType& key) const;

    template< class DATATYPE > SPTR(DATATYPE) getOutput(const KeyType& key) const;

    template< class DATATYPE > CSPTR(DATATYPE) getInput(const KeyType& keybase, size_t index) const;

    template< class DATATYPE > SPTR(DATATYPE) getInOut(const KeyType& keybase, size_t index) const;

    template< class DATATYPE > SPTR(DATATYPE) getOutput(const KeyType& keybase, size_t index) const;

    FWSERVICES_API void setOutput(const ::fwServices::IService::KeyType& key, const ::fwData::Object::sptr& object,
                                  size_t index = 0);

    size_t getKeyGroupSize(const KeyType& keybase) const;


    typedef ::fwCom::helper::SigSlotConnection::KeyConnectionsType KeyConnectionsType;

    class KeyConnectionsMap
    {
    public:
        //------------------------------------------------------------------------------

        void push (const KeyType& key,
                   const ::fwCom::Signals::SignalKeyType& sig,
                   const ::fwCom::Slots::SlotKeyType& slot)
        {
            m_keyConnectionsMap[key].push_back(std::make_pair(sig, slot));
        }

        typedef std::map< KeyType, KeyConnectionsType> KeyConnectionsMapType;

        //------------------------------------------------------------------------------

        KeyConnectionsMapType::const_iterator find(const KeyType& key) const
        {
            return m_keyConnectionsMap.find(key);
        }
        //------------------------------------------------------------------------------

        KeyConnectionsMapType::const_iterator end() const
        {
            return m_keyConnectionsMap.cend();
        }
        //------------------------------------------------------------------------------

        bool empty() const
        {
            return m_keyConnectionsMap.empty();
        }
        //------------------------------------------------------------------------------

        size_t size() const
        {
            return m_keyConnectionsMap.size();
        }

    private:
        std::map< KeyType, KeyConnectionsType> m_keyConnectionsMap;
    };

    FWSERVICES_API virtual KeyConnectionsType getObjSrvConnections() const;



    FWSERVICES_API friend std::ostream& operator<<(std::ostream& _sstream, IService& _service);

    FWSERVICES_API bool hasObjectId(const KeyType& _key) const;

    FWSERVICES_API IdType getObjectId(const KeyType& _key) const;

    FWSERVICES_API void setObjectId(const KeyType& _key, const IdType& _id);

    FWSERVICES_API void registerInput(const ::fwData::Object::csptr& obj, const std::string& key,
                                      const bool autoConnect = false, const bool optional = false);

    FWSERVICES_API void registerInOut(const ::fwData::Object::sptr& obj, const std::string& key,
                                      const bool autoConnect = false, const bool optional = false);

protected:


    FWSERVICES_API IService();

    FWSERVICES_API virtual ~IService();



    FWSERVICES_API virtual void starting() = 0;

    FWSERVICES_API virtual void stopping() = 0;

    virtual void swapping()
    {
    }

    virtual void swapping(const KeyType& key)
    {
    }

    FWSERVICES_API virtual void configuring() = 0;

    FWSERVICES_API virtual void reconfiguring();

    FWSERVICES_API virtual void updating() = 0;

    FWSERVICES_API virtual void info( std::ostream& _sstream );

    FWSERVICES_API virtual KeyConnectionsMap getAutoConnections() const;

    ::fwRuntime::ConfigurationElement::sptr m_configuration;

    ::fwData::Object::wptr m_associatedObject;


    StartSlotType::sptr m_slotStart;

    StopSlotType::sptr m_slotStop;

    UpdateSlotType::sptr m_slotUpdate;

    SwapSlotType::sptr m_slotSwap;

    SwapKeySlotType::sptr m_slotSwapKey;

    SPTR(::fwThread::Worker) m_associatedWorker;


private:

    // Slot: start the service
    SharedFutureType startSlot();
    SharedFutureType internalStart(bool _async);

    // Slot: stop the service
    SharedFutureType stopSlot();
    SharedFutureType internalStop(bool _async);

    // Slot: swap the object
    SharedFutureType swapSlot(::fwData::Object::sptr _obj);
    SharedFutureType internalSwap(::fwData::Object::sptr _obj, bool _async);

    // Slot: swap an object
    SharedFutureType swapKeySlot(const KeyType& _key, ::fwData::Object::sptr _obj);
    SharedFutureType internalSwapKey(const KeyType& _key, ::fwData::Object::sptr _obj, bool _async);

    // Slot: update the service
    SharedFutureType updateSlot();
    SharedFutureType internalUpdate(bool _async);

    FWSERVICES_API void connectToConfig();

    FWSERVICES_API void disconnectFromConfig();

    FWSERVICES_API void autoConnect();

    FWSERVICES_API void autoDisconnect();

    FWSERVICES_API void addProxyConnection(const helper::ProxyConnections& info);

    InputMapType m_inputsMap;

    InOutMapType m_inOutsMap;

    OutputMapType m_outputsMap;

    std::map<KeyType, IdType> m_idsMap;

    std::map<std::string, size_t> m_keyGroupSize;

    GlobalStatus m_globalState;

    UpdatingStatus m_updatingState;

    ConfigurationStatus m_configurationState;

    ::fwServices::IService::Config m_serviceConfig;

    ::fwCom::helper::SigSlotConnection m_srvConnections;

    ::fwCom::helper::SigSlotConnection m_autoConnections;

    std::map<std::string, helper::ProxyConnections> m_proxies;
};

} // namespace fwServices

#include "fwServices/IService.hxx"