BufferManager.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 __FWMEMORY_BUFFERMANAGER_HPP__
#define __FWMEMORY_BUFFERMANAGER_HPP__

#include "fwMemory/BufferInfo.hpp"
#include "fwMemory/config.hpp"
#include "fwMemory/FileHolder.hpp"

#include <fwCom/Signal.hpp>

#include <fwCore/base.hpp>
#include <fwCore/BaseObject.hpp>
#include <fwCore/mt/types.hpp>

#include <boost/filesystem/path.hpp>

#include <future>

namespace fwThread
{
class Worker;
}

namespace fwMemory
{

class IPolicy;

namespace stream
{
namespace in
{
class IFactory;
}
}

class BufferManager;

class Key
{
friend SPTR(BufferManager) getDefault();

Key()
{
}
};

class FWMEMORY_CLASS_API BufferManager : public ::fwCore::BaseObject
{
public:

    typedef void* BufferType;
    typedef const void* ConstBufferType;
    typedef BufferType* BufferPtrType;
    typedef void const* const* ConstBufferPtrType;

    typedef BufferInfo::SizeType SizeType;

    typedef ::fwCom::Signal< void () > UpdatedSignalType;

    typedef std::map< ConstBufferPtrType, BufferInfo > BufferInfoMapType;

    fwCoreNonInstanciableClassDefinitionsMacro( (BufferManager)(::fwCore::BaseObject) );
    fwCoreAllowSharedFromThis();

    BufferManager();
    virtual ~BufferManager();

    typedef enum
    {
        DIRECT,
        LAZY
    } LoadingModeType;

    struct BufferStats
    {
        SizeType totalDumped;
        SizeType totalManaged;
    };

    struct StreamInfo
    {
        SizeType size;
        SPTR(std::istream) stream;
        ::fwMemory::FileHolder fsFile;
        ::fwMemory::FileFormatType format;
        bool userStream;
    };

    FWMEMORY_API virtual std::shared_future<void> registerBuffer(BufferPtrType bufferPtr);

    FWMEMORY_API virtual std::shared_future<void> unregisterBuffer(BufferPtrType bufferPtr);

    FWMEMORY_API virtual std::shared_future<void> allocateBuffer(BufferPtrType bufferPtr, SizeType size,
                                                                 const ::fwMemory::BufferAllocationPolicy::sptr& policy);

    FWMEMORY_API virtual std::shared_future<void> setBuffer(BufferPtrType bufferPtr,
                                                            ::fwMemory::BufferManager::BufferType buffer,
                                                            SizeType size,
                                                            const ::fwMemory::BufferAllocationPolicy::sptr& policy);

    FWMEMORY_API virtual std::shared_future<void> reallocateBuffer(BufferPtrType bufferPtr, SizeType newSize);

    FWMEMORY_API virtual std::shared_future<void> destroyBuffer(BufferPtrType bufferPtr);

    FWMEMORY_API virtual std::shared_future<void> swapBuffer(BufferPtrType bufA, BufferPtrType bufB);

    FWMEMORY_API virtual std::shared_future<SPTR(void)> lockBuffer(ConstBufferPtrType bufferPtr);

    FWMEMORY_API virtual std::shared_future<bool> unlockBuffer(ConstBufferPtrType bufferPtr);

    FWMEMORY_API virtual std::shared_future<std::string> toString() const;

    FWMEMORY_API std::shared_future<bool> dumpBuffer(ConstBufferPtrType bufferPtr);
    FWMEMORY_API std::shared_future<bool> restoreBuffer(ConstBufferPtrType bufferPtr);
    FWMEMORY_API std::shared_future<bool> writeBuffer(ConstBufferType buffer, SizeType size,
                                                      ::boost::filesystem::path& path);
    FWMEMORY_API std::shared_future<bool> readBuffer(BufferType buffer, SizeType size,
                                                     ::boost::filesystem::path& path);
    SPTR(UpdatedSignalType) getUpdatedSignal(){
        return m_updatedSig;
    };

    FWMEMORY_API std::shared_future<BufferInfoMapType> getBufferInfos() const;

    FWMEMORY_API std::shared_future<BufferStats> getBufferStats() const;
    FWMEMORY_API static BufferStats computeBufferStats(const BufferInfoMapType& bufferInfo);

    FWMEMORY_API void setDumpPolicy( const SPTR(::fwMemory::IPolicy)& policy );

    FWMEMORY_API SPTR(::fwMemory::IPolicy) getDumpPolicy() const;

    FWMEMORY_API std::shared_future<StreamInfo> getStreamInfo(const ConstBufferPtrType bufferPtr) const;

    FWMEMORY_API std::shared_future<void> setIStreamFactory(BufferPtrType bufferPtr,
                                                            const SPTR(::fwMemory::stream::in::IFactory)& factory,
                                                            SizeType size,
                                                            ::fwMemory::FileHolder fsFile,
                                                            ::fwMemory::FileFormatType format,
                                                            const ::fwMemory::BufferAllocationPolicy::sptr& policy
                                                            );

    FWMEMORY_API LoadingModeType getLoadingMode() const;
    FWMEMORY_API void setLoadingMode(LoadingModeType mode);

    FWMEMORY_API static BufferManager::sptr getDefault();

    ::fwCore::mt::ReadWriteMutex& getMutex() const
    {
        return m_mutex;
    }
protected:

    virtual void registerBufferImpl(BufferPtrType bufferPtr);
    virtual void unregisterBufferImpl(BufferPtrType bufferPtr);
    virtual void allocateBufferImpl(BufferPtrType bufferPtr, SizeType size,
                                    const ::fwMemory::BufferAllocationPolicy::sptr& policy);
    virtual void setBufferImpl(BufferPtrType bufferPtr, ::fwMemory::BufferManager::BufferType buffer, SizeType size,
                               const ::fwMemory::BufferAllocationPolicy::sptr& policy);
    virtual void reallocateBufferImpl(BufferPtrType bufferPtr, SizeType newSize);
    virtual void destroyBufferImpl(BufferPtrType bufferPtr);
    virtual void swapBufferImpl(BufferPtrType bufA, BufferPtrType bufB);
    virtual SPTR(void) lockBufferImpl(ConstBufferPtrType bufferPtr);
    virtual bool unlockBufferImpl(ConstBufferPtrType bufferPtr);
    virtual std::string toStringImpl() const;
    bool dumpBufferImpl(ConstBufferPtrType buffer);
    bool restoreBufferImpl(ConstBufferPtrType buffer);
    bool writeBufferImpl(ConstBufferType buffer, SizeType size, ::boost::filesystem::path& path);
    bool readBufferImpl(BufferType buffer, SizeType size, ::boost::filesystem::path& path);
    BufferInfoMapType getBufferInfosImpl() const;
    StreamInfo getStreamInfoImpl(const ConstBufferPtrType bufferPtr) const;
    void setIStreamFactoryImpl(BufferPtrType bufferPtr,
                               const SPTR(::fwMemory::stream::in::IFactory)& factory,
                               SizeType size,
                               ::fwMemory::FileHolder fsFile,
                               ::fwMemory::FileFormatType format,
                               const ::fwMemory::BufferAllocationPolicy::sptr& policy
                               );
    FWMEMORY_API bool dumpBuffer(BufferInfo& info, BufferPtrType bufferPtr);
    FWMEMORY_API bool restoreBuffer(BufferInfo& info, BufferPtrType bufferPtr, SizeType size = 0);
    SPTR(UpdatedSignalType) m_updatedSig;

    ::fwCore::LogicStamp m_lastAccess;
    BufferInfoMapType m_bufferInfos;

    SPTR(::fwMemory::IPolicy) m_dumpPolicy;

    LoadingModeType m_loadingMode;

    SPTR(fwThread::Worker) m_worker;

    mutable ::fwCore::mt::ReadWriteMutex m_mutex;
};

}

#endif /* __FWMEMORY_BUFFERMANAGER_HPP__ */