io/fwGdcmIO/include/fwGdcmIO/reader/SeriesDB.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 "fwGdcmIO/config.hpp"
#include "fwGdcmIO/exception/Failed.hpp"

#include <fwData/location/Folder.hpp>
#include <fwData/location/MultiFiles.hpp>

#include <fwDataIO/reader/GenericObjectReader.hpp>

#include <fwLog/Logger.hpp>

#include <fwMedData/DicomSeries.hpp>
#include <fwMedData/SeriesDB.hpp>

#include <fwServices/IService.hpp>

namespace fwJobs
{
class Aggregator;
class IJob;
class Observer;
}

namespace fwGdcmIO
{

namespace reader
{

class FWGDCMIO_CLASS_API SeriesDB : public ::fwDataIO::reader::GenericObjectReader< ::fwMedData::SeriesDB >,
                                    public ::fwData::location::enableFolder< ::fwDataIO::reader::IObjectReader >,
                                    public ::fwData::location::enableMultiFiles< ::fwDataIO::reader::IObjectReader >,
                                    public ::fwCom::HasSignals
{

public:

    fwCoreClassDefinitionsWithFactoryMacro(
        (SeriesDB)( ::fwDataIO::reader::GenericObjectReader< ::fwMedData::SeriesDB > ),
        (()), ::fwDataIO::reader::factory::New< SeriesDB >);

    typedef std::vector< SPTR(::fwMedData::DicomSeries) > DicomSeriesContainerType;
    typedef std::vector< std::string > FilenameContainerType;
    typedef std::vector< std::string > SupportedSOPClassContainerType;

    FWGDCMIO_API SeriesDB(::fwDataIO::reader::IObjectReader::Key key);

    FWGDCMIO_API ~SeriesDB();

    FWGDCMIO_API void read() override;

    FWGDCMIO_API void readFromDicomSeriesDB(const ::fwMedData::SeriesDB::csptr& dicomSeriesDB,
                                            const ::fwServices::IService::sptr& notifier
                                                = ::fwServices::IService::sptr());

    FWGDCMIO_API void readDicomSeries();

    FWGDCMIO_API bool isDicomDirAvailable();

    FWGDCMIO_API DicomSeriesContainerType& getDicomSeries();

    const bool& getDicomdirActivated() const
    {
        return m_isDicomdirActivated;
    }

    void setDicomdirActivated(const bool& isDicomdirActivated)
    {
        m_isDicomdirActivated = isDicomdirActivated;
    }

    const std::string& getDicomFilterType() const
    {
        return m_dicomFilterType;
    }

    void setDicomFilterType(const std::string& dicomFilterType)
    {
        m_dicomFilterType = dicomFilterType;
    }

    const SupportedSOPClassContainerType& getSupportedSOPClassContainer() const
    {
        return m_supportedSOPClassContainer;
    }

    void setSupportedSOPClassContainer(const SupportedSOPClassContainerType& supportedSOPClassContainer)
    {
        m_supportedSOPClassContainer = supportedSOPClassContainer;
    }

    const ::fwLog::Logger::sptr& getLogger() const
    {
        return m_logger;
    }

    void setLogger(const ::fwLog::Logger::sptr& logger)
    {
        m_logger = logger;
    }

    FWGDCMIO_API SPTR(::fwJobs::IJob) getJob() const override;

    void setBufferRotationEnabled(bool enabled)
    {
        m_enableBufferRotation = enabled;
    }

private:

    void readDicom();

    void convertDicomSeries(const ::fwServices::IService::sptr& notifier = ::fwServices::IService::sptr());

    static bool dicomSeriesComparator(const SPTR(::fwMedData::DicomSeries)& a,
                                      const SPTR(::fwMedData::DicomSeries)& b);

    DicomSeriesContainerType m_dicomSeriesContainer;

    bool m_isDicomdirActivated;

    std::string m_dicomFilterType;

    SupportedSOPClassContainerType m_supportedSOPClassContainer;

    ::fwLog::Logger::sptr m_logger;

    SPTR(::fwJobs::Aggregator) m_job;

    bool m_enableBufferRotation;

    SPTR(::fwJobs::Observer) m_dicomdirFileLookupJob;
    SPTR(::fwJobs::Observer) m_regularFileLookupJob;
    SPTR(::fwJobs::Observer) m_readerJob;
    SPTR(::fwJobs::Observer) m_completeDicomSeriesJob;
    SPTR(::fwJobs::Observer) m_converterJob;
};

}  // namespace reader

}  // namespace fwGdcmIO