19

*  Item is byte.

    20

*  The word 'simple' means:

    21

*    - no configurable allocator type (always made from heap)

    22

*    - no smart deallocation - deallocation must be called from the same

    23

*        module (DLL) where the blob was allocated

    24

*    - no configurable allocation policy (how big blocks should be allocated)

    25

*    - no extra ownership policy (i.e. 'copy on write') when blob is copied

    26

*    - no thread synchronization at all

    27

*

    28

*  Internal member layout:

    29

*  1. The only class member is pointer to the first item (see union ptr_u).

    30

*  2. Allocated block contains the blob header (see CHdr) followed by the raw byte data.

    31

*     Always, when it allocates memory the allocated size is:

    32

*                                                      sizeof(CHdr) + <data capacity>

    33

*  3. Two 'virtual' members (m_size and m_max_size) are stored in the CHdr at beginning

    34

*     of the alloated block.

    35

*  4. The pointter (in ptr_u) pobsize_ts behind the header (to the first data byte).

    36

*     When memory block is allocated, the sizeof(CHdr) it added to it.

    37

*  5. Benefits of this layout:

    38

*     - items are accessed in the simplest possible way - just dereferencing the pointer,

    39

*       which is good for performance (assuming that data are accessed most often).

    40

*     - sizeof(blob) is the same as the size of any other pointer

    41

*  6. Drawbacks of this layout:

    42

*     - the fact, that pointer to the alocated block is adjusted by sizeof(CHdr) before

    43

*       it is stored can lead to several confusions:

    44

*         - it is not common pattern so the implementation code is bit harder to read

    45

*         - valgrind can generate warning that allocated block is lost (not accessible)

    46

* */

    48

public:

    49

	typedef ::ptrdiff_t bsize_t;

    50

	typedef ::byte      bitem_t;

    51

    55

		bsize_t    m_size;      ///< actual blob size in bytes

    56

		bsize_t    m_max_size;  ///< maximum (allocated) size in bytes

    61

		bitem_t    *m_pData;    ///< ptr to the first byte of data

    62

		wchar_t    *m_pwData;   ///< ptr to the first byte of data

    63

		CHdr       *m_pHdr_1;   ///< ptr just after the CHdr holding m_size and m_max_size

    67

	static const bsize_t Ttail_reserve = 4; ///< four extra bytes will be always allocated and zeroed at the end

    71

	/** constructor - create blob with data */

    72

	FORCEINLINE CBlobBaseSimple(const bitem_t *p, bsize_t num_bytes)

    73

	{

    74

		InitEmpty();

    75

		AppendRaw(p, num_bytes);

    76

	}

    77

    84

    85

	/** move constructor - take ownership of blob data */

    86

	FORCEINLINE CBlobBaseSimple(CHdr * const & pHdr_1)

    87

	{

    88

		assert(pHdr_1 != NULL);

    89

		ptr_u.m_pHdr_1 = pHdr_1;

    90

		*(CHdr**)&pHdr_1 = NULL;

    91

	}

    92

    94

	FORCEINLINE ~CBlobBaseSimple()

    95

	{

    96

		Free();

    97

	}

    98

   101

	*  both m_size and m_max_size containing zero */

   102

	FORCEINLINE void InitEmpty()

   103

	{

   104

		static CHdr hdrEmpty[] = {{0, 0}, {0, 0}};

   105

		ptr_u.m_pHdr_1 = &hdrEmpty[1];

   106

	}

   107

   109

	FORCEINLINE void Init(CHdr* hdr)

   110

	{

   111

		ptr_u.m_pHdr_1 = &hdr[1];

   112

	}

   113

   115

	FORCEINLINE CHdr& Hdr()

   116

	{

   117

		return ptr_u.m_pHdr_1[-1];

   118

	}

   119

   121

	FORCEINLINE const CHdr& Hdr() const

   122

	{

   123

		return ptr_u.m_pHdr_1[-1];

   124

	}

   125

   127

	FORCEINLINE bsize_t& RawSizeRef()

   128

	{

   129

		return Hdr().m_size;

   130

	};

   134

	FORCEINLINE bool IsEmpty() const

   135

	{

   136

		return RawSize() == 0;

   137

	}

   138

   140

	FORCEINLINE bsize_t RawSize() const

   141

	{

   142

		return Hdr().m_size;

   143

	};

   144

   146

	FORCEINLINE bsize_t MaxRawSize() const

   147

	{

   148

		return Hdr().m_max_size;

   149

	};

   150

   152

	FORCEINLINE bitem_t* RawData()

   153

	{

   154

		return ptr_u.m_pData;

   155

	}

   156

   158

	FORCEINLINE const bitem_t* RawData() const

   159

	{

   160

		return ptr_u.m_pData;

   161

	}

   162

   164

	//FORCEINLINE bsize_t Crc32() const

   165

	//{

   166

	//	return CCrc32::Calc(RawData(), RawSize());

   167

	//}

   168

   170

	FORCEINLINE void Clear()

   171

	{

   172

		RawSizeRef() = 0;

   173

	}

   174

   176

	FORCEINLINE void Free()

   177

	{

   178

		if (MaxRawSize() > 0) {

   179

			RawFree(&Hdr());

   180

			InitEmpty();

   181

		}

   182

	}

   183

   185

	FORCEINLINE void CopyFrom(const CBlobBaseSimple& src)

   186

	{

   187

		Clear();

   188

		AppendRaw(src);

   189

	}

   190

   192

	FORCEINLINE void MoveFrom(CBlobBaseSimple& src)

   193

	{

   194

		Free();

   195

		ptr_u.m_pData = src.ptr_u.m_pData;

   196

		src.InitEmpty();

   197

	}

   198

   200

	FORCEINLINE void Swap(CBlobBaseSimple& src)

   201

	{

   202

		bitem_t *tmp = ptr_u.m_pData; ptr_u.m_pData = src.ptr_u.m_pData;

   203

		src.ptr_u.m_pData = tmp;

   204

	}

   207

	FORCEINLINE void AppendRaw(const void *p, bsize_t num_bytes)

   225

	*  @return pointer to the new data to be added */

   226

	FORCEINLINE bitem_t* MakeRawFreeSpace(bsize_t num_bytes)

   229

		bsize_t new_size = RawSize() + num_bytes;

   235

	*  @return pointer to the new data added */

   236

	FORCEINLINE bitem_t* GrowRawSize(bsize_t num_bytes)

   238

		bitem_t* pNewData = MakeRawFreeSpace(num_bytes);

   244

	FORCEINLINE void ReduceRawSize(bsize_t num_bytes)

   252

   254

	void SmartAlloc(bsize_t new_size)

   256

		bsize_t old_max_size = MaxRawSize();

   259

		bsize_t min_alloc_size = sizeof(CHdr) + new_size + Ttail_reserve;

   261

		bsize_t alloc_size = AllocPolicy(min_alloc_size);

   276

   278

	FORCEINLINE static bsize_t AllocPolicy(bsize_t min_alloc)

   297

	static FORCEINLINE CHdr* RawAlloc(bsize_t num_bytes)

   298

	{

   299

		return (CHdr*)malloc(num_bytes);

   300

	}

   301

   303

	static FORCEINLINE void RawFree(CHdr* p)

   304

	{

   305

		free(p);

   306

	}

   308

	FORCEINLINE void FixTail() const

   311

			bitem_t *p = &ptr_u.m_pData[RawSize()];

   312

			for (bsize_t i = 0; i < Ttail_reserve; i++) {

   313

				p[i] = 0;

   314

			}

   320

*  Titem_ can be any integral type, pointer, or structure. Using Blob instead of just plain C array

   321

*  simplifies the resource management in several ways:

   322

*  1. When adding new item(s) it automatically grows capacity if needed.

   323

*  2. When variable of type Blob comes out of scope it automatically frees the data buffer.

   324

*  3. Takes care about the actual data size (number of used items).

   325

*  4. Dynamically constructs only used items (as opposite of static array which constructs all items) */

   327

class CBlobT : public Tbase_ {

   332

	typedef typename Tbase::bsize_t bsize_t;

   334

	static const bsize_t Titem_size = sizeof(Titem);

   335

   336

	struct OnTransfer {

   337

		typename Tbase_::CHdr *m_pHdr_1;

   338

		OnTransfer(const OnTransfer& src) : m_pHdr_1(src.m_pHdr_1) {assert(src.m_pHdr_1 != NULL); *(typename Tbase_::CHdr**)&src.m_pHdr_1 = NULL;}

   339

		OnTransfer(CBlobT& src) : m_pHdr_1(src.ptr_u.m_pHdr_1) {src.InitEmpty();}

   340

		~OnTransfer() {assert(m_pHdr_1 == NULL);}

   341

	};

   344

	FORCEINLINE CBlobT()

   345

		: Tbase()

   346

	{}

   347

   348

	/** Constructor - makes new Blob with data */

   349

	FORCEINLINE CBlobT(const Titem_ *p, bsize_t num_items)

   350

		: Tbase((typename Tbase_::bitem_t*)p, num_items * Titem_size)

   351

	{}

   352

   354

	FORCEINLINE CBlobT(const Tbase& src)

   355

		: Tbase(src)

   356

	{

   357

		assert((Tbase::RawSize() % Titem_size) == 0);

   358

	}

   359

   360

	/** Take ownership constructor */

   361

	FORCEINLINE CBlobT(const OnTransfer& ot)

   362

		: Tbase(ot.m_pHdr_1)

   363

	{}

   364

   366

	FORCEINLINE ~CBlobT()

   367

	{

   368

		Free();

   369

	}

   370

   372

	FORCEINLINE void CheckIdx(bsize_t idx)

   373

	{

   374

		assert(idx >= 0); assert(idx < Size());

   375

	}

   376

   378

	FORCEINLINE Titem* Data()

   379

	{

   380

		return (Titem*)Tbase::RawData();

   381

	}

   382

   384

	FORCEINLINE const Titem* Data() const

   385

	{

   386

		return (const Titem*)Tbase::RawData();

   387

	}

   388

   390

	FORCEINLINE Titem* Data(bsize_t idx)

   391

	{

   392

		CheckIdx(idx);

   393

		return (Data() + idx);

   394

	}

   395

   397

	FORCEINLINE const Titem* Data(bsize_t idx) const

   398

	{

   399

		CheckIdx(idx); return (Data() + idx);

   400

	}

   401

   403

	FORCEINLINE bsize_t Size() const

   404

	{

   405

		return (Tbase::RawSize() / Titem_size);

   406

	}

   407

   408

	/** Return total number of items that can fit in the Blob without buffer reallocation */

   409

	FORCEINLINE bsize_t MaxSize() const

   410

	{

   411

		return (Tbase::MaxRawSize() / Titem_size);

   412

	}

   413

	/** Return number of additional items that can fit in the Blob without buffer reallocation */

   414

	FORCEINLINE bsize_t GetReserve() const

   415

	{

   416

		return ((Tbase::MaxRawSize() - Tbase::RawSize()) / Titem_size);

   417

	}

   418

   422

		assert((Tbase::RawSize() % Titem_size) == 0);

   423

		bsize_t old_size = Size();

   431

   433

	FORCEINLINE Titem* GrowSizeNC(bsize_t num_items)

   434

	{

   435

		return (Titem*)Tbase::GrowRawSize(num_items * Titem_size);

   436

	}

   437

   439

	FORCEINLINE Titem* GrowSizeC(bsize_t num_items)

   442

		for (bsize_t i = num_items; i > 0; i--, pI++) new (pI) Titem();

   444

   446

	FORCEINLINE void ReduceSize(bsize_t num_items)

   448

		assert((Tbase::RawSize() % Titem_size) == 0);

   449

		bsize_t old_size = Size();

   451

		bsize_t new_size = (num_items <= old_size) ? (old_size - num_items) : 0;

   456

		Tbase::ReduceRawSize(num_items * Titem_size);

   458

   466

   474

   476

	FORCEINLINE Titem* Append(const Titem* pSrc, bsize_t num_items)

   484

   486

	FORCEINLINE void RemoveBySwap(bsize_t idx)

   493