/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * This file is part of xlslib -- A multiplatform, C/C++ library
 * for dynamic generation of Excel(TM) files.
 *
 * xlslib is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * xlslib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with xlslib.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * Copyright 2004 Yeico S. A. de C. V.
 * Copyright 2008 David Hoerl
 *  
 * $Source: /cvsroot/xlslib/xlslib/src/xlslib/unit.cpp,v $
 * $Revision: 1.3 $
 * $Author: dhoerl $
 * $Date: 2008/10/25 18:39:54 $
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 * File description:
 *
 *
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include <XLS/systype.h>
#include <XLS/unit.h>

using namespace std;
using namespace xlslib_core;

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

// Default constructor
CUnit::CUnit() : m_nSize(0), m_pData(0), m_nDataSize(0)
   //, m_ShadowUnit(false)
{

}

// Default destructor
CUnit::~CUnit (  )
{
   if(m_pData /*&& !m_ShadowUnit*/)
   {
      delete[] m_pData;
   }

}
/************************************************
 ************************************************/

const unsigned8_t CUnit::DefaultInflateSize = 10;

/************************************************
 ************************************************/

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

   if(m_pData != NULL)
   {
      if (index < m_nDataSize)
         m_pData[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;

}


/************************************************
 ************************************************/

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

   if(SetAt(BYTE_0(newval), index  )) errcode = GENERAL_ERROR;
   if(SetAt(BYTE_1(newval), index+1)) errcode = GENERAL_ERROR;
  
   return errcode;
}

/************************************************
 ************************************************/

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

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

   return errcode;
}


/************************************************
 ************************************************/

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

   *val = (signed16_t)(operator[](index) + 
                       operator[](index+1)*0x0100);

   return errcode;
}

/************************************************
 ************************************************/

signed8_t CUnit::GetValue32From(signed32_t* val, unsigned32_t index)
{
   signed8_t errcode = NO_ERRORS;

   *val = (signed16_t)(operator[](index)  *0x0000001 + 
                       operator[](index+1)*0x0000100 +
                       operator[](index+2)*0x0010000 +
                       operator[](index+2)*0x1000000  );
   return errcode;
}

/************************************************
 ************************************************/

signed8_t CUnit::GetAt(signed8_t* data, unsigned32_t  index)
{
   signed8_t errcode = NO_ERRORS;

   if(m_pData != NULL)
   {
      if (index < m_nDataSize)
      {
         *data = m_pData[index];
      } else {
         errcode =  ERR_INVALID_INDEX;
      }
   } else {
      errcode =  ERR_DATASTORAGE_EMPTY;
   }
  
   return errcode;

}
/************************************************
 ************************************************/
/*
  signed8_t CUnit::GetData(unsigned8_t** ppdata, unsigned32_t from, unsigned32_t to )
  {
  signed8_t errcode = NO_ERRORS;

  // Simply make the external pointer point to the local storage data
  *ppdata = m_pData;

  return errcode;
  }
*/
/************************************************
 ************************************************/
signed8_t CUnit::AddDataArray (const unsigned8_t* newdata, size_t size)
{

   signed8_t errcode = NO_ERRORS;
   size_t spaceleft = m_nSize - m_nDataSize;
  
   if(spaceleft < size) // allocate more space if new tobeadded array won't fit
   {
      Inflate(size-spaceleft+1);
   }

   if(newdata != NULL)
   {
      for(unsigned32_t i=0; i<size; i++)
         m_pData[m_nDataSize++] = newdata[i];
   } else {
      //No data to add. Do nothing
   }

   return errcode;
}

signed8_t CUnit::AddFixedDataArray (const unsigned8_t value, size_t size)
{

   signed8_t errcode = NO_ERRORS;
   size_t spaceleft = m_nSize - m_nDataSize;
  
   if(spaceleft < size) // allocate more space if new tobeadded array won't fit
   {
      Inflate(size-spaceleft+1);
   }

   // The following can be a memset
   for(unsigned32_t i=0; i<size; i++)
      m_pData[m_nDataSize++] = value;


   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::RemoveTrailData (unsigned32_t remove_size)
{
   /*
     total_to_remove = (m_nSize - m_nDataSize) - remove_size;
     size of temp_data = m_nSize - total_to_remove = m_nDataSize + remove_size
   */
   unsigned32_t temp_size = m_nDataSize + remove_size;
   unsigned8_t* temp_data = new unsigned8_t[temp_size];
  
   if(temp_data != NULL)
   {
      for(unsigned32_t i=0; i<temp_size; i++)
         temp_data[i] = m_pData[i];
   } else {
      return GENERAL_ERROR;
   }
  
   m_nDataSize = temp_size;
   m_nSize = m_nDataSize;
   delete[] m_pData;
   m_pData = temp_data;

   return NO_ERRORS;
}

/************************************************
 ************************************************/

signed8_t CUnit::SetArrayAt(const unsigned8_t* newdata, size_t size, unsigned32_t index)
{

   signed8_t errcode = NO_ERRORS;
   size_t spaceleft = m_nSize - index;

   if(spaceleft < size) // allocate more space if new tobeadded array won't fit
   {
      Inflate(size-spaceleft);
   }

   if(newdata != NULL)
   {
      for(unsigned32_t i=0; i<size; i++)
      {
         /*
         // The following code adds needed space to the whole allocated array
         if (index > m_nDataSize) m_nDataSize = index+1;
         else if(index==m_nDataSize) m_nDataSize++;
         m_pData[index++] = newdata[i];
         */
         // The following code truncates the array if it exceeds DataSize
         if(index==m_nDataSize) break;
		 
         m_pData[index++] = newdata[i];
      }
   } else {
      //No data to add. Do nothing
   }

   return errcode;
}

/************************************************
 ************************************************/

signed8_t CUnit::AddValue8(unsigned8_t newdata)
{
  
   if(m_nDataSize >= m_nSize) 
   {
      Inflate();
   }

   m_pData[m_nDataSize++] = newdata;

   return NO_ERRORS;
  
}

#if VERSION_BIFF == VERSION_BIFF8
#ifdef HAVE_ICONV
void  CUnit::Conv32to16(string& iconv_code, ustring& str1, u16string& str2)
{
	size_t					resultSize, inbytesleft, outbytesleft;
	const wchar_t			*inbuf;
	iconv_t					cd;
	unsigned16_t			*outbuf, *origOutbuf;
	static unsigned16_t		convFail[] = { 'i', 'c', 'o', 'n', 'v', ' ', 'f', 'a', 'i', 'l', 'e', 'd', '!' };
	
	cd = iconv_open("UCS-2-INTERNAL", "wchar_t");
	// no need to test return code as we ALREADY did this when setting iconv_code in workbook
	
	inbytesleft		= str1.size() * sizeof(uchar_t);
	outbytesleft	= inbytesleft * 4 * sizeof(unsigned16_t); // Unicode expansion 4 to 2 ???

	inbuf		= str1.c_str();
	origOutbuf	= (unsigned16_t *)calloc(outbytesleft, 1);
	outbuf		= origOutbuf;

	resultSize = iconv(cd, (char **)&inbuf, &inbytesleft, (char **)&outbuf, &outbytesleft);
	iconv_close(cd);

	if(resultSize == (size_t)-1) {
		str2 = convFail;
	} else {
		str2.assign(origOutbuf, outbuf - origOutbuf);
	}
	return;
}
#endif

// for cases where we save a single byte
signed8_t CUnit::AddUnicodeStrlen(unsigned8_t newdata)
{
  return AddValue8(newdata);  
}
// for cases where we save a single byte
signed8_t CUnit::AddUnicodeStrlen(unsigned16_t newdata)
{
  return AddValue16(newdata);  
}
signed8_t CUnit::AddUnicodeString (const unsigned8_t* newdata, unsigned16_t size)
{
   unsigned16_t	strSize = 1 + size;

   signed8_t errcode = NO_ERRORS;
   size_t spaceleft = m_nSize - m_nDataSize;
  
   if(spaceleft < strSize) // allocate more space if new tobeadded array won't fit
   {
		Inflate((size_t)(strSize-spaceleft+1));
   }

   m_pData[m_nDataSize++] = 0x00;	// character compression

   if(newdata != NULL)
   {
      for(unsigned16_t i=0; i<size; i++)
         m_pData[m_nDataSize++] = newdata[i];
   } else {
      //No data to add. Do nothing
   }

   return errcode;
}
signed8_t CUnit::AddUnicodeString (const unsigned16_t* newdata, unsigned16_t size)
{
   unsigned16_t	strSize = 1 + size*sizeof(unsigned16_t);

   signed8_t errcode = NO_ERRORS;
   size_t spaceleft = m_nSize - m_nDataSize;
  
   if(spaceleft < strSize) // allocate more space if new tobeadded array won't fit
   {
      Inflate((size_t)(strSize-spaceleft+1));
   }

   m_pData[m_nDataSize++] = 0x01;	// UTF-16

   if(newdata != NULL)
   {
      for(unsigned16_t i=0; i<size; i++) {
		 unsigned16_t	data;

		 data = newdata[i];
		 
         m_pData[m_nDataSize++] = data & 0xFF;
         m_pData[m_nDataSize++] = (data >> 8) & 0xFF;
	  }
   } else {
      //No data to add. Do nothing
   }

   return errcode;
}
#endif

/************************************************
 ************************************************/

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

   if (increase == 0)
      increase = CUnit::DefaultInflateSize;
  
   // Create the new storage with increased size
   // and initialize it to 0.
   unsigned8_t* temp_storage = new unsigned8_t[m_nSize + increase];

   if(temp_storage != NULL)
   {

      memset(temp_storage, 0, (m_nSize+increase)*(sizeof(unsigned8_t)));
      // Copy data to the new storage
      memcpy(temp_storage, m_pData, m_nSize*sizeof(unsigned8_t));
  
      // Update the size
      m_nSize += increase;
  
      if (m_pData != NULL)
         delete []m_pData;

      m_pData = temp_storage;
     
      errcode = ERR_UNNABLE_TOALLOCATE_MEMORY;
   } else {
      // No errors... errcode already clean
   }
  
   return errcode;
}

/************************************************
 ************************************************/

unsigned8_t& CUnit::operator[] ( const unsigned32_t index )
{
   if(index >= m_nDataSize)
      return m_pData[m_nDataSize];
   return m_pData[index];

}
/************************************************
 ************************************************/

CUnit& CUnit::operator= (CUnit& newvalue )
{
   if(&newvalue != this)
      Init(newvalue.GetBuffer(), newvalue.GetSize(), newvalue.GetDataSize());
  
   return *this;
  
}

/************************************************
 ************************************************/

CUnit& CUnit::operator+= ( CUnit& from )
{
  
   if(&from != this)
      Append(from);
   else
   {
      CUnit shadow;
      shadow  = from;
      Append(shadow);
   }
   return *this;
}

/************************************************
 ************************************************/

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

   return *this;
}


/************************************************
 ************************************************/

signed8_t CUnit::Init (unsigned8_t* data, const size_t size, const unsigned32_t datasz)
{

   m_nSize		= size;
   m_nDataSize	= datasz;

   m_pData = new unsigned8_t[m_nSize];
  
   if(data)
   {
      memset(m_pData, 0, m_nSize*sizeof(unsigned8_t));
      // Copy data to the new storage
      memcpy(m_pData, data, m_nSize*sizeof(unsigned8_t));
   }

   return NO_ERRORS;
}


/************************************************
 ************************************************/

signed8_t CUnit::Append (CUnit& newunit)
{

   if(AddDataArray(newunit.GetBuffer(), newunit.GetDataSize()) == NO_ERRORS)
      return NO_ERRORS;
   else
      return GENERAL_ERROR;
}

/************************************************
 ************************************************/
signed8_t CUnit::InitFill (unsigned8_t data, unsigned32_t size)
{
   if(m_pData)
      delete[] m_pData;

   m_pData = new unsigned8_t[size];

   if(m_pData)
   {
      memset(m_pData, data, size*sizeof(unsigned8_t));
      m_nSize = m_nDataSize = size;

      return NO_ERRORS;
   } else {
      return GENERAL_ERROR;
   }

}

/************************************************
 ************************************************/

size_t CUnit::GetSize (void)
{
   return m_nSize;
}

/************************************************
 ************************************************/

unsigned32_t CUnit::GetDataSize (void)
{
   return m_nDataSize;
}

/************************************************
 ************************************************/

unsigned8_t* CUnit::GetBuffer (void)
{
   return m_pData;
}


/************************************************
 ************************************************/
/*
  void CUnit::SetShadow(bool shadowval)
  {
  m_ShadowUnit = shadowval;


  }
*/

/************************************************
 ************************************************/
/*
  void CUnit::CopyShadowUnit(unsigned8_t* data, unsigned32_t size)
  {
  m_Size = m_DataSize = size;
  m_pData = data;

  SetShadow(true);



  }
*/

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * $Log: unit.cpp,v $
 * Revision 1.3  2008/10/25 18:39:54  dhoerl
 * 2008
 *
 * Revision 1.2  2004/09/01 00:47:21  darioglz
 * + Modified to gain independence of target
 *
 * Revision 1.1.1.1  2004/08/27 16:31:53  darioglz
 * Initial Import.
 *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */