BufferObject.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 "fwMemory/BufferAllocationPolicy.hpp"
#include "fwMemory/BufferManager.hpp"
#include "fwMemory/config.hpp"

#include <fwCamp/macros.hpp>

#include <boost/filesystem/path.hpp>

#include <istream>
#include <type_traits>

fwCampAutoDeclareMacro((fwMemory)(BufferObject), FWMEMORY_API);

namespace fwMemory
{

namespace stream
{
namespace in
{
class IFactory;
}
}

class FWMEMORY_CLASS_API BufferObject : public ::fwCore::BaseObject
{

public:

    typedef std::shared_ptr< void > CounterType;
    typedef std::weak_ptr< void > WeakCounterType;

    typedef size_t SizeType;

    fwCoreClassDefinitionsWithFactoryMacro((BufferObject), (()), new BufferObject );
    fwCoreAllowSharedFromThis();

    std::string className() const
    {
        return this->getClassname();
    }

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

    virtual ::fwMemory::BufferManager::BufferType getBuffer() const
    {
        return m_buffer;
    }

    template <typename T>
    class LockBase
    {
    public:

        typedef typename ::boost::conditional< std::is_const< T >::value, const void*, void* >::type BufferType;

        LockBase()
        {
        }

        LockBase( const SPTR(T)& bo ) :
            m_bufferObject(bo)
        {
            SLM_ASSERT("Can't lock NULL object", bo);

            ::fwCore::mt::ScopedLock lock(bo->m_lockDumpMutex);
            m_count = bo->m_count.lock();
            if ( !m_count )
            {
                m_count     = bo->m_bufferManager->lockBuffer(&(bo->m_buffer)).get();
                bo->m_count = m_count;
            }

        }

        typename LockBase<T>::BufferType getBuffer() const
        {
            SPTR(T) bufferObject = m_bufferObject.lock();
            BufferType buffer = bufferObject->m_buffer;
            return buffer;
        }

        void reset()
        {
            m_count.reset();
            m_bufferObject.reset();
        }

    protected:

        BufferObject::CounterType m_count;
        WPTR(T) m_bufferObject;
    };

    typedef LockBase<BufferObject> Lock;
    typedef LockBase<const BufferObject> ConstLock;
    FWMEMORY_API BufferObject();

    FWMEMORY_API virtual ~BufferObject();

    FWMEMORY_API virtual void allocate(SizeType size,
                                       const ::fwMemory::BufferAllocationPolicy::sptr& policy =
                                           ::fwMemory::BufferMallocPolicy::New());

    FWMEMORY_API virtual void reallocate(SizeType size);

    FWMEMORY_API virtual void destroy();

    FWMEMORY_API virtual void setBuffer(::fwMemory::BufferManager::BufferType buffer, SizeType size,
                                        const ::fwMemory::BufferAllocationPolicy::sptr& policy =
                                            ::fwMemory::BufferMallocPolicy::New());

    FWMEMORY_API virtual Lock lock();

    FWMEMORY_API virtual ConstLock lock() const;

    SizeType getSize() const
    {
        return m_size;
    }

    bool isEmpty() const
    {
        return m_size == 0;
    }

    long lockCount() const
    {
        return m_count.use_count();
    }

    long isLocked() const
    {
        return lockCount() != 0;
    }

    const ::fwMemory::BufferManager::ConstBufferPtrType getBufferPointer() const
    {
        return &m_buffer;
    }

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

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

    FWMEMORY_API void swap( const BufferObject::sptr& _source );

    FWMEMORY_API BufferManager::StreamInfo getStreamInfo() const;

    FWMEMORY_API void setIStreamFactory(const SPTR(::fwMemory::stream::in::IFactory)& factory,
                                        SizeType size,
                                        const ::boost::filesystem::path& sourceFile            = "",
                                        ::fwMemory::FileFormatType format                      = ::fwMemory::OTHER,
                                        const ::fwMemory::BufferAllocationPolicy::sptr& policy = ::fwMemory::BufferMallocPolicy::New()
                                        );

protected:

    ::fwMemory::BufferManager::BufferType m_buffer;

    SizeType m_size;

    mutable WeakCounterType m_count;
    mutable ::fwCore::mt::Mutex m_lockDumpMutex;
    ::fwCore::mt::ReadWriteMutex m_mutex;

    ::fwMemory::BufferManager::sptr m_bufferManager;

    ::fwMemory::BufferAllocationPolicy::sptr m_allocPolicy;
};

}