ioPacs/include/ioPacs/SSeriesPuller.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 "ioPacs/config.hpp"

#include <fwCom/Slot.hpp>

#include <fwIO/IReader.hpp>

#include <fwMedData/SeriesDB.hpp>

#include <fwPacsIO/data/PacsConfiguration.hpp>
#include <fwPacsIO/SeriesEnquirer.hpp>
#include <fwPacsIO/SeriesRetriever.hpp>

#include <fwServices/IController.hpp>

#include <fwThread/Worker.hpp>

#include <boost/filesystem/path.hpp>

#include <vector>

namespace fwMedData
{
class DicomSeries;
}

namespace ioPacs
{

class IOPACS_CLASS_API SSeriesPuller : public ::fwServices::IController
{
public:

    fwCoreServiceClassDefinitionsMacro( (SSeriesPuller)( ::fwServices::IController ) );

    typedef ::fwMedData::SeriesDB::ContainerType DicomSeriesContainerType;
    typedef std::vector< std::string > InstanceUIDContainerType;
    typedef std::map < std::string, unsigned int > InstanceCountMapType;
    typedef std::map < std::string, WPTR(::fwMedData::DicomSeries) > DicomSeriesMapType;

    IOPACS_API static const ::fwCom::Slots::SlotKeyType s_READ_SLOT;
    typedef ::fwCom::Slot<void (DicomSeriesContainerType)> ReadDicomSlotType;

    IOPACS_API static const ::fwCom::Slots::SlotKeyType s_DISPLAY_SLOT;
    typedef ::fwCom::Slot<void (const std::string&)> DisplayMessageSlotType;

    typedef ::fwCom::Signal< void ( std::string ) > StartedProgressSignalType;
    typedef ::fwCom::Signal< void ( std::string, float, std::string ) > ProgressedSignalType;
    typedef ::fwCom::Signal< void ( std::string ) > StoppedProgressSignalType;

    static const ::fwCom::Signals::SignalKeyType s_PROGRESSED_SIG;
    static const ::fwCom::Signals::SignalKeyType s_STARTED_PROGRESS_SIG;
    static const ::fwCom::Signals::SignalKeyType s_STOPPED_PROGRESS_SIG;

    IOPACS_API SSeriesPuller() noexcept;

    IOPACS_API virtual ~SSeriesPuller() noexcept;

protected:

    IOPACS_API virtual void configuring() override;

    IOPACS_API virtual void starting() override;

    IOPACS_API virtual void stopping() override;

    IOPACS_API void updating() override;

    IOPACS_API void info(std::ostream& _sstream ) override;

protected:

    IOPACS_API void pullSeries();

    IOPACS_API void readLocalSeries(DicomSeriesContainerType selectedSeries);

    IOPACS_API void displayErrorMessage(const std::string& message) const;

    IOPACS_API void storeInstanceCallback(const std::string& seriesInstanceUID, unsigned int instanceNumber,
                                          const std::string& filePath);

    ReadDicomSlotType::sptr m_slotReadLocalSeries;

    DisplayMessageSlotType::sptr m_slotDisplayMessage;

    ::fwPacsIO::SeriesRetriever::ProgressCallbackSlotType::sptr m_slotStoreInstanceCallbackUsingMoveRequests;

    ::fwPacsIO::SeriesEnquirer::ProgressCallbackSlotType::sptr m_slotStoreInstanceCallbackUsingGetRequests;

    ProgressedSignalType::sptr m_sigProgressed;

    StartedProgressSignalType::sptr m_sigStartedProgress;

    StoppedProgressSignalType::sptr m_sigStoppedProgress;

    ::fwPacsIO::SeriesEnquirer::sptr m_seriesEnquirer;

    ::fwPacsIO::data::PacsConfiguration::csptr m_pacsConfiguration;

    ::fwIO::IReader::sptr m_dicomReader;

    std::string m_dicomReaderSrvConfig;

    std::string m_dicomReaderType;

    ::fwMedData::SeriesDB::sptr m_tempSeriesDB;

    ::fwMedData::SeriesDB::sptr m_destinationSeriesDB;

    ::fwThread::Worker::sptr m_pullSeriesWorker;

    InstanceUIDContainerType m_localSeries;

    bool m_isPulling;

    std::string m_progressbarId;

    long unsigned int m_seriesCount;

    unsigned int m_seriesIndex;

    std::size_t m_instanceCount;

    DicomSeriesMapType m_pullingDicomSeriesMap;
};

} // namespace ioPacs