/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * This file is part of xlslib -- A multiplatform, C/C++ library
 * for dynamic generation of Excel(TM) files.
 *
 * Copyright 2004 Yeico S. A. de C. V. All Rights Reserved.
 * Copyright 2008-2013 David Hoerl All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of
 *       conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
 *       of conditions and the following disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY David Hoerl ''AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL David Hoerl OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifdef __BCPLUSPLUS__
#include <memory.h>
// string.h needed for memcpy(). RLN 111215
// This may be applicable to other compilers as well.
#endif

#include "../xlslib/record.h"
#include "../xlslib/unit.h"
#include "../xlslib/globalrec.h"
#include "../xlslib/rectypes.h"
#include "../xlslib/datast.h"

using namespace xlslib_core;
using namespace xlslib_strings;

/*
 *********************************************************************************
 *  CUnit class implementation
 *********************************************************************************
 */

// Default constructor
CUnit::CUnit(CDataStorage &datastore) :
	m_Store(datastore),
	m_Index(INVALID_STORE_INDEX),
	m_Backpatching_Level(0),
	m_AlreadyContinued(false)
{
	datastore.Push(this);
}

CUnit::CUnit(const CUnit& orig) :
	m_Store(orig.m_Store),
	m_Index(INVALID_STORE_INDEX),
	m_Backpatching_Level(0)
{
	XL_ASSERT(m_Index == INVALID_STORE_INDEX);
	if (orig.m_Index != INVALID_STORE_INDEX) {
		m_Index = m_Store.RequestIndex(orig.GetDataSize());
		if (m_Index != INVALID_STORE_INDEX)	{
			XL_ASSERT(m_Index >= 0);
			XL_ASSERT(m_Store[m_Index].GetSize() >= orig.GetDataSize());
			memcpy(m_Store[m_Index].GetBuffer(), orig.GetBuffer(), orig.GetDataSize());
		} else {
			// TODO: mark error. Should we throw an exception from this constructor?
		}
	}
}

CUnit& CUnit::operator=(const CUnit& right)
{
	if(this == &right) {
		return *this;
	}

	size_t len = right.GetDataSize();
	if (m_Index == INVALID_STORE_INDEX && right.m_Index != INVALID_STORE_INDEX)	{
		m_Index = m_Store.RequestIndex(len);
		if (m_Index == INVALID_STORE_INDEX)	{
			// TODO: mark error.
		}
	} else
	if (right.m_Index != INVALID_STORE_INDEX)	{
		signed8_t ret = m_Store[m_Index].Resize(len);
		if (ret != NO_ERRORS) {
			// TODO mark error
		}
		XL_ASSERT(ret == NO_ERRORS);
	}
	XL_ASSERT(right.m_Index != INVALID_STORE_INDEX && m_Index != INVALID_STORE_INDEX);
	if (right.m_Index != INVALID_STORE_INDEX && m_Index != INVALID_STORE_INDEX)	{
		XL_ASSERT(m_Store[m_Index].GetSize() >= len);
		memcpy(m_Store[m_Index].GetBuffer(), right.GetBuffer(), len);
		m_Store[m_Index].SetDataSize(len);
	}

	return *this;
}

// Default destructor
CUnit::~CUnit()
{
	ResetDataStorage();
}

void CUnit::ResetDataStorage(void)
{
	if (m_Index != INVALID_STORE_INDEX)	{
		XL_ASSERT(m_Index >= 0 ? !m_Store[m_Index].IsSticky() : 1);
		XL_ASSERT(m_Index < 0 ? m_Store[m_Index].IsSticky() : 1);
		if (m_Index >= 0) {
			m_Store[m_Index].Reset();
		}
	}
	m_Index = INVALID_STORE_INDEX;
}

const size_t CUnit::DefaultInflateSize = 10;

signed8_t CUnit::SetValueAt8(unsigned8_t newval, unsigned32_t index)
{
	signed8_t errcode = NO_ERRORS;

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	size_t datasize = m_Store[m_Index].GetDataSize();

	if(data != NULL) {
		XL_ASSERT(m_Store[m_Index].GetSize() >= datasize);
		if (index < datasize) {
			data[index] = newval;
		} else {
			errcode = ERR_INVALID_INDEX;
		}
	} else {
		errcode = ERR_DATASTORAGE_EMPTY;
	}

	return errcode;
}

signed8_t CUnit::AddValue16(unsigned16_t newval)
{
	signed8_t errcode = NO_ERRORS;

	if(AddValue8(BYTE_0(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_1(newval))) { errcode = GENERAL_ERROR; }

	return errcode;
}

signed8_t CUnit::AddValue32(unsigned32_t newval)
{
	signed8_t errcode = NO_ERRORS;

	if(AddValue8(BYTE_0(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_1(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_2(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_3(newval))) { errcode = GENERAL_ERROR; }

	return errcode;
}

signed8_t CUnit::AddValue64(unsigned64_t newval)
{
	signed8_t errcode = NO_ERRORS;

	if(AddValue8(BYTE_0(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_1(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_2(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_3(newval))) { errcode = GENERAL_ERROR; }

	if(AddValue8(BYTE_4(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_5(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_6(newval))) { errcode = GENERAL_ERROR; }
	if(AddValue8(BYTE_7(newval))) { errcode = GENERAL_ERROR; }

	return errcode;
}

unsigned64_t CUnit::EncodeFP2I64(double newval)
{
//#include "common/xls_pshpack1.h"

	union
	{
		double f;
		unsigned64_t i;
		unsigned8_t b[8];
	} v;

//#include "common/xls_poppack.h"

	XL_ASSERT(sizeof(v.f) == sizeof(v.i));
	XL_ASSERT(sizeof(v.f) == sizeof(v.b));
	XL_ASSERT(sizeof(v) == sizeof(v.f));

	v.f = newval;

	return v.i;
}

signed8_t CUnit::AddValue64FP(double newval)
{
	unsigned64_t i = EncodeFP2I64(newval);

	return AddValue64(i);
}

signed8_t CUnit::SetValueAt16(unsigned16_t newval, unsigned32_t index)
{
	signed8_t errcode = NO_ERRORS;

	if(SetValueAt8(BYTE_0(newval), index  )) {errcode = GENERAL_ERROR; }
	if(SetValueAt8(BYTE_1(newval), index+1)) { errcode = GENERAL_ERROR; }

	return errcode;
}

signed8_t CUnit::SetValueAt32(unsigned32_t newval, unsigned32_t index)
{
	signed8_t errcode = NO_ERRORS;

	if(SetValueAt8(BYTE_0(newval), index  )) {errcode = GENERAL_ERROR; }
	if(SetValueAt8(BYTE_1(newval), index+1)) { errcode = GENERAL_ERROR; }
	if(SetValueAt8(BYTE_2(newval), index+2)) { errcode = GENERAL_ERROR; }
	if(SetValueAt8(BYTE_3(newval), index+3)) { errcode = GENERAL_ERROR; }

	return errcode;
}

signed8_t CUnit::GetValue16From(unsigned16_t* val, unsigned32_t index) const
{
	signed8_t errcode = NO_ERRORS;

	*val = (unsigned16_t)(operator[](index) +
						  operator[](index+1)*0x0100U);

	return errcode;
}

signed8_t CUnit::GetValue32From(unsigned32_t* val, unsigned32_t index) const
{
	signed8_t errcode = NO_ERRORS;
	// Yikes! this was signed16_t - DFH
	*val = (unsigned32_t)(operator[](index)*0x00000001U +
						  operator[](index+1)*0x00000100U +
						  operator[](index+2)*0x00010000U +
						  operator[](index+3)*0x01000000U); // Yikes again, it was
	return errcode;
}

signed8_t CUnit::GetValue8From(unsigned8_t* dst, unsigned32_t index) const
{
	signed8_t errcode = NO_ERRORS;

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	size_t datasize = m_Store[m_Index].GetDataSize();

	if(dst != NULL) {
		XL_ASSERT(m_Store[m_Index].GetSize() >= datasize);
		if (index < datasize) {
			*dst = data[index];
		} else {
			errcode = ERR_INVALID_INDEX;
		}
	} else {
		errcode = ERR_DATASTORAGE_EMPTY;
	}

	return errcode;
}

signed8_t CUnit::AddDataArray(const unsigned8_t* newdata, size_t size)
{
	signed8_t errcode = NO_ERRORS;

	if (m_Index == INVALID_STORE_INDEX)	{
		m_Index = m_Store.RequestIndex(size);
		if (m_Index == INVALID_STORE_INDEX)	{
			return GENERAL_ERROR;
		}
	}

	XL_ASSERT(GetSize() >= GetDataSize());
	size_t spaceleft = GetSize() - GetDataSize();

	if(spaceleft < size) { // allocate more space if new to-be-added array won't fit
		errcode = Inflate(size + GetDataSize());
		if (errcode != NO_ERRORS) {
			return errcode;
		}
	}

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	size_t datasize = m_Store[m_Index].GetDataSize();

	if(newdata != NULL) {
		// TODO: memmove() (not memcpy() as can be called from Append() <-- this += *this; fringe case where memcpy() would possibly fail!
		for(size_t i=0; i<size; i++) {
			XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
			data[datasize++] = newdata[i];
		}

		m_Store[m_Index].SetDataSize(datasize);
	} else {
		//No data to add. Do nothing
		if (size != 0) {
			return GENERAL_ERROR; // [i_a] at least report this very suspicious situation
		}
	}

	return errcode;
}

signed8_t CUnit::AddFixedDataArray(const unsigned8_t value, size_t size)
{
	signed8_t errcode = NO_ERRORS;

	if (m_Index == INVALID_STORE_INDEX)	{
		m_Index = m_Store.RequestIndex(size);
		if (m_Index == INVALID_STORE_INDEX)	{
			return GENERAL_ERROR;
		}
	}

	XL_ASSERT(GetSize() >= GetDataSize());
	size_t spaceleft = GetSize() - GetDataSize();

	if(spaceleft < size) { // allocate more space if new to-be-added array won't fit
		errcode = Inflate(size + GetDataSize());
		if (errcode != NO_ERRORS) {
			return errcode;
		}
	}

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	size_t datasize = m_Store[m_Index].GetDataSize();

	// The following can be a memset
	for(size_t i=0; i<size; i++) {
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = value;
	}

	m_Store[m_Index].SetDataSize(datasize);

	return errcode;
}

//    signed8_t AddDataArray (const unsigned16_t* newdata, size_t size);
//    signed8_t AddFixedDataArray (const unsigned16_t value, size_t size);

signed8_t CUnit::SetArrayAt(const unsigned8_t* newdata, size_t size, unsigned32_t index)
{
	signed8_t errcode = NO_ERRORS;
	size_t space = GetSize();

	if(space < size + index) { // allocate more space if new to-be-added array won't fit
		errcode = Inflate(size + index);
		if (errcode != NO_ERRORS) {
			return errcode;
		}
	}

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	//size_t datasize = m_Store[m_Index].GetDataSize();

	if (newdata != NULL) {
		for (size_t i=0; i<size; i++) {
			XL_ASSERT(m_Store[m_Index].GetSize() > index);
			data[index++] = newdata[i];
		}
	}

	return errcode;
}

signed8_t CUnit::AddValue8(unsigned8_t newdata)
{
	XL_ASSERT(GetSize() >= GetDataSize());
	if(GetDataSize() >= GetSize()) {
		signed8_t errcode = Inflate(GetDataSize() + 1);
		if (errcode != NO_ERRORS) {
			return errcode;
		}
	}

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	size_t datasize = m_Store[m_Index].GetDataSize();

	data[datasize++] = newdata;

	m_Store[m_Index].SetDataSize(datasize);

	return NO_ERRORS;
}

signed8_t CUnit::AddUnicodeString(CGlobalRecords& gRecords, const std::string& str, XlsUnicodeStringFormat_t fmt)
{
	std::string::const_iterator	cBegin, cEnd;
	signed8_t errcode = NO_ERRORS;
	size_t strSize = 0;
	size_t strLen;
	size_t spaceleft;
	bool isASCII = CGlobalRecords::IsASCII(str);

	if (!isASCII) {
		u16string s16;

		XL_ASSERTS("Should never happen!");

		gRecords.char2str16(str, s16);
		return AddUnicodeString(s16, fmt);
	}

	strLen = str.length();

	switch (fmt) {
	case LEN2_FLAGS_UNICODE:			// RECTYPE_FORMAT, RECTYPE_LABEL -- 'regular'
		strSize = 2;
		strSize += 1;   // flags byte
		break;

	case LEN1_FLAGS_UNICODE:			// RECTYPE_BOUNDSHEET
		strSize = 1;
		strSize += 1;   // flags byte
		break;

	case NOLEN_FLAGS_UNICODE:			// RECTYPE_NAME
		strSize = 0;
		strSize += 1;   // flags byte
		break;

	default:
		XL_ASSERTS("should never go here!");
		break;
	}
	strSize += strLen;

	XL_ASSERT(GetSize() >= GetDataSize());
	spaceleft = GetSize() - GetDataSize();
	if(spaceleft < strSize)	{ // allocate more space if new to-be-added array won't fit
		errcode = Inflate(strSize + GetDataSize());
		if (errcode != NO_ERRORS) {
			return errcode;
		}
	}

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	size_t datasize = m_Store[m_Index].GetDataSize();
	XL_ASSERT(data);
	//XL_ASSERT(datasize > strSize);

	switch (fmt) {
	case LEN2_FLAGS_UNICODE: // RECTYPE_FORMAT, RECTYPE_LABEL -- 'regular'
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = strLen & 0xFF;
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = (strLen >> 8) & 0xFF;
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = 0x00; // ASCII
		break;

	case LEN1_FLAGS_UNICODE: // RECTYPE_BOUNDSHEET
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = strLen & 0xFF;
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = 0x00; // ASCII
		break;

	case NOLEN_FLAGS_UNICODE: // RECTYPE_NAME
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = 0x00; // ASCII
		break;

	default:
		XL_ASSERTS("should never go here!");
		break;
	}

	cBegin	 = str.begin();
	cEnd = str.end();

	while(cBegin != cEnd) {
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = (unsigned8_t)*cBegin++;
	}

	m_Store[m_Index].SetDataSize(datasize);

	return errcode;
}

signed8_t CUnit::AddUnicodeString(const u16string& str16, XlsUnicodeStringFormat_t fmt)
{
	u16string::const_iterator cBegin, cEnd;
	signed8_t errcode = NO_ERRORS;
	size_t spaceleft;
	size_t strLen;
	bool isASCII;
	size_t strSize = UnicodeStringLength(str16, strLen, isASCII, fmt /* = LEN2_FLAGS_UNICODE */ );

	XL_ASSERT(GetSize() >= GetDataSize());
	spaceleft = GetSize() - GetDataSize();
	if(spaceleft < strSize)	{ // allocate more space if new to-be-added array won't fit
		errcode = Inflate(strSize + GetDataSize());
		if (errcode != NO_ERRORS) {
			return errcode;
		}
	}

	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	size_t datasize = m_Store[m_Index].GetDataSize();
	XL_ASSERT(data);
	//XL_ASSERT(datasize > strSize);

	switch (fmt) {
	case LEN2_FLAGS_UNICODE: // RECTYPE_FORMAT, RECTYPE_LABEL -- 'regular'
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = strLen & 0xFF;
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = (strLen >> 8) & 0xFF;
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = (isASCII ? 0x00 : 0x01); // ASCII or UTF-16
		break;

	case LEN1_FLAGS_UNICODE: // RECTYPE_BOUNDSHEET
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = strLen & 0xFF;
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = (isASCII ? 0x00 : 0x01); // ASCII or UTF-16
		break;

	case NOLEN_FLAGS_UNICODE: // RECTYPE_NAME
		XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
		data[datasize++] = (isASCII ? 0x00 : 0x01); // ASCII or UTF-16
		break;

	default:
		XL_ASSERTS("should never go here!");
		break;
	}

	cBegin	= str16.begin();
	cEnd	= str16.end();

	if (isASCII) {
		while(cBegin != cEnd) {
			unsigned16_t c = *cBegin++;

			XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
			data[datasize++] = static_cast<unsigned8_t>(c);
		}
	} else {
		while(cBegin != cEnd) {
			unsigned16_t c = *cBegin++;

			XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
			data[datasize++] = c & 0xFF;
			XL_ASSERT(m_Store[m_Index].GetSize() > datasize);
			data[datasize++] = (c >> 8) & 0xFF;
		}
	}
	m_Store[m_Index].SetDataSize(datasize);

	return errcode;
}

size_t CUnit::UnicodeStringLength(const u16string& str16, size_t& strLen, bool& isASCII, XlsUnicodeStringFormat_t fmt /* = LEN2_FLAGS_UNICODE */ )
{
	strLen = str16.length();
	isASCII = CGlobalRecords::IsASCII(str16);
	size_t strSize = strLen;

	switch (fmt) {
	case LEN2_FLAGS_UNICODE:			// RECTYPE_FORMAT, RECTYPE_LABEL -- 'regular'
		strSize += 2;
		strSize += 1;   // flags byte
		if (!isASCII) {
			strSize += strLen;  // UTF16 takes 2 bytes per char
		}
		break;

	case LEN1_FLAGS_UNICODE:			// RECTYPE_BOUNDSHEET
		strSize += 1;
		strSize += 1;   // flags byte
		if (!isASCII) {
			strSize += strLen;  // UTF16 takes 2 bytes per char
		}
		break;

	case NOLEN_FLAGS_UNICODE:			// RECTYPE_NAME
		//strSize = 0;
		strSize += 1;   // flags byte
		if (!isASCII) {
			strSize += strLen;  // UTF16 takes 2 bytes per char
		}
		break;

	default:
		XL_ASSERTS("should never go here!");
		break;
	}

	return strSize;
}

signed8_t CUnit::Inflate(size_t newsize)
{
	signed8_t errcode = NO_ERRORS;

	if (m_Index == INVALID_STORE_INDEX)	{
		XL_ASSERT(newsize > 0);
		m_Index = m_Store.RequestIndex(newsize);
		if (m_Index == INVALID_STORE_INDEX)	{
			return GENERAL_ERROR;
		}
	} else {
		XL_ASSERT(newsize > 0);
#if 0
		{
			size_t oldlen = m_Store[m_Index].GetSize();
			if (oldlen < 64) {
				increase = CUnit::DefaultInflateSize;
			} else {
				// bigger units grow faster: save on the number of realloc redimension operations...
				increase = oldlen / 2;
			}
		}
#endif
		XL_ASSERT(m_Index != INVALID_STORE_INDEX);
		errcode = m_Store[m_Index].Resize(newsize);
	}

	return errcode;
}

unsigned8_t& CUnit::operator[](const size_t index) const
{
	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	unsigned8_t *data = m_Store[m_Index].GetBuffer();
	//size_t datasize = m_Store[m_Index].GetDataSize();

	XL_ASSERT(index < GetSize());       // DFH: need to read ahead when setting bits in 32bit words
	XL_ASSERT(index < GetDataSize());   // [i_a]
	//if(index >= datasize) printf("ERROR: Short read!! \n");

	return data[index];
}

CUnit& CUnit::operator +=(const CUnit& from)
{
	XL_VERIFY(NO_ERRORS == Append(from));

	return *this;
}

CUnit& CUnit::operator +=(unsigned8_t from)
{
	XL_VERIFY(NO_ERRORS == AddValue8(from));

	return *this;
}

signed8_t CUnit::Init(const unsigned8_t* data, const size_t size, const unsigned32_t datasz)
{
	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	signed8_t ret = m_Store[m_Index].Init(data, size, datasz);
	return ret;
}

signed8_t CUnit::Append(const CUnit& newunit)
{
	XL_ASSERT(GetSize() >= GetDataSize());
	size_t spaceleft = GetSize() - GetDataSize();
	if(spaceleft < newunit.GetDataSize()) { // allocate more space if new to-be-added array won't fit
		signed8_t errcode = Inflate(GetDataSize() + newunit.GetDataSize());
		if (errcode != NO_ERRORS) {
			return errcode;
		}
	}

	return AddDataArray(newunit.GetBuffer(), newunit.GetDataSize());
}

signed8_t CUnit::InitFill(unsigned8_t data, size_t size)
{
	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	return m_Store[m_Index].InitWithValue(data, size);
}

size_t CUnit::GetSize(void) const
{
	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	return m_Store[m_Index].GetSize();
}

size_t CUnit::GetDataSize(void) const
{
	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	return m_Store[m_Index].GetDataSize();
}

const unsigned8_t* CUnit::GetBuffer(void) const
{
	XL_ASSERT(m_Index != INVALID_STORE_INDEX);
	return m_Store[m_Index].GetBuffer();
}