Deliver/include/TmplBlockBuffer.tlh

//

#pragma once

#include <memory>


////////////////////////////////////////////////////////////////////////////////
//	TmplBuffer - 定义一个连续的内存块
//
//	Copyright (c) 1997-2019 E-COM Technology Ltd.
//
//	V1.0	??			- Initial Version
//	V2.0	2019-10-31	- Use std::shared_ptr & std::unique_ptr
//	V2.1	2019-11-08	- Define TmplBuffer_Base as the base class
//	V2.2	2020-06-17  - add TmplSharedBuffer (TmplUniqueBuffer <T> && from)


namespace ECOM
{
namespace Utility
{


//-----------------------------------------------------------------------------
//		TmplBuffer_Base
//	基本类
//-----------------------------------------------------------------------------

template <typename T, typename PTR>
class TmplBuffer_Base
{
protected:
	int	 m_nCount;		// count of data, 注意是 数量 而不是 字节 长度 !!!

	PTR  m_Data;

public:
	TmplBuffer_Base ()
	{
		m_nCount = 0;
	}

	TmplBuffer_Base (TmplBuffer_Base && from)
	{
		m_Data = std::move (from.m_Data);
		m_nCount = from.m_nCount;
		from.m_nCount = 0;
	}

	void Attach (T * object, int count)
	{
		if (! object)
		{
			m_Data.reset ();
			m_nCount = 0;
			return;
		}

		m_Data.reset (object);
		m_nCount = count;
	}

public:
//	operator bool () const { return ! IsEmpty (); }
	operator T * () { return m_Data.get (); }
	operator const T * () const { return m_Data.get (); }

public:
	// Allow usage as a pointer	
	T * operator -> ()
	{
		return m_Data.get ();
	}

	const T * operator -> ()  const
	{
		return m_Data.get ();
	}

	T * As ()
	{
		return m_Data.get ();
	}

	const T * As () const
	{
		return m_Data.get ();
	}

public:
	int  GetCount () const
	{
		return m_nCount;
	}

	int  GetNbOfBytes () const
	{
		return m_nCount * sizeof (T);
	}

	bool IsEmpty () const { return (m_Data.get () == nullptr); }

public:
	void Release () { m_Data.reset (); m_nCount = 0; }

public:
	TmplBuffer_Base & operator = (const TmplBuffer_Base & from) = delete;
	TmplBuffer_Base & operator = (TmplBuffer_Base && from) = delete;

public:
	// MemCpy
	void MemCopyFrom (const T * from, int count);
	void MemCopyTo (T * to, int count) const;

protected:
	T * _GetBufferSetCount (int count);

	void MoveAssign (TmplBuffer_Base & from)
	{
		m_Data = std::move (from.m_Data);
		m_nCount = from.m_nCount;
		from.m_nCount = 0;
	}

	//	make a real copy
	void MemCopyTo (TmplBuffer_Base & To) const;
	void ResizeTo (int count, TmplBuffer_Base & To) const;
};

template <typename T>
class TmplUniqueBuffer;

template <typename T>
class TmplSharedBuffer;

//-----------------------------------------------------------------------------
//		TmplSharedBuffer
//
//	定义一个连续的内存块, 用 shared_ptr 定义, 因此可以在多个模块之间共享
//-----------------------------------------------------------------------------

template <typename T>
class TmplSharedBuffer : public TmplBuffer_Base <T, std::shared_ptr <T>>
{
	typedef TmplBuffer_Base <T, std::shared_ptr <T>> inherited;

public:
	TmplSharedBuffer ()
	{
	}

#if 1
	explicit TmplSharedBuffer (T * from, int count)
	{
		m_Data.reset (from);
		m_nCount = count;
	}
#endif

	TmplSharedBuffer (const TmplSharedBuffer & from)
	{
		m_Data = from.m_Data;
		m_nCount = from.m_nCount;
	}

	TmplSharedBuffer (TmplSharedBuffer && from) : inherited (std::move (from))
	{
	}

	TmplSharedBuffer (TmplUniqueBuffer <T> && from);

	TmplSharedBuffer & operator = (const TmplSharedBuffer & from)
	{
		m_Data = from.m_Data;
		m_nCount = from.m_nCount;
		return *this;
	}

	TmplSharedBuffer & operator = (TmplSharedBuffer && from)
	{
		MoveAssign (from);
		return (*this);
	}

	TmplSharedBuffer & operator = (TmplUniqueBuffer <T> && from);

public:
	T * GetBufferSetCount (int count)
	{
		return inherited::_GetBufferSetCount (count);
	}

	// return real copy
	TmplSharedBuffer Clone () const
	{
		TmplSharedBuffer <T> To;
		inherited::MemCopyTo (To);
		return std::move (To);
	}

	//	调整大小, 只要前面的 count 个对象
	//	如果要的数量比我现有的数量 (m_nCount) 多,就重新分配,然后memcpy,但填充值由上层自行决定
	TmplSharedBuffer Resize (int count) const
	{
		TmplSharedBuffer <T> To;
		inherited::ResizeTo (count, To);
		return std::move (To);
	}
};



//-----------------------------------------------------------------------------
//		TmplUniqueBuffer
//	用 unique_ptr 定义, 不能共享, 但是可以转移
//-----------------------------------------------------------------------------

template <typename T>
class TmplUniqueBuffer : public TmplBuffer_Base <T, std::unique_ptr <T>>
{
	typedef TmplBuffer_Base <T, std::unique_ptr <T>> inherited;

public:
	TmplUniqueBuffer ()
	{
		m_nCount = 0;
	}

	explicit TmplUniqueBuffer (T * from, int count)
	{
		m_Data.reset (from);
		m_nCount = count;
	}


	TmplUniqueBuffer (TmplUniqueBuffer && from) : inherited (std::move (from))
	{
	}

	TmplUniqueBuffer (const TmplUniqueBuffer & from) = delete;
	TmplUniqueBuffer & operator = (const TmplUniqueBuffer & from) = delete;

	TmplUniqueBuffer & operator = (TmplUniqueBuffer && from)
	{
		MoveAssign (from);
		return (*this);
	}

public:
	T * GetBufferSetCount (int count)
	{
		return inherited::_GetBufferSetCount (count);
	}

	// return real copy
	TmplUniqueBuffer Clone () const
	{
		TmplUniqueBuffer <T> To;
		inherited::MemCopyTo (To);
		return std::move (To);
	}

public:
	T * Detach () { m_nCount = 0; auto pc = m_Data.release (); ASSERT (pc);  return pc; }
};


}

}



//	共享版本
//	为像素数据定义一个专用的类型
typedef ECOM::Utility::TmplSharedBuffer <unsigned char>  BlockBuffer;

//	非共享版本
typedef ECOM::Utility::TmplUniqueBuffer <unsigned char>  UniqueBuffer;

typedef UniqueBuffer IBlockBuffer;
typedef UniqueBuffer OBlockBuffer;