CBin::t_size CBin::Copy( CBin *x_p )
{_STT();
// Just ensuring our internal buffer is unshared?
if ( !x_p )
{
// Where's the buffer we're dealing with?
t_size nUsed = getUsed();
const CBin::t_byte* ptr = Ptr();
// Valid buffer?
if ( 0 >= nUsed || !ptr )
{ Destroy();
return 0;
} // end if
// User ptr buffer?
if ( m_ptr )
m_buf.MemCpy( ptr, nUsed ), FreePtr();
// Make a copy of shared pointer
else
{ t_buffer buf;
buf.MemCpy( ptr, nUsed );
m_buf.Assume( buf );
} // end else if
// Restore used count
m_nUsed = nUsed;
m_nOffset = 0;
return nUsed;
} // end if
// Valid buffer?
if ( !x_p->Ptr() || !x_p->getUsed() )
{ Destroy();
return 0;
} // end if
// Lose Ptr buffer if any
FreePtr();
m_nUsed = x_p->getUsed();
// Ptr buffer?
m_buf.MemCpy( x_p->Ptr(), m_nUsed );
return m_nUsed;
}
template <class T,int Overhead> void LIST<T,Overhead>::DeleteAll(void){
for(int i=0;i<Items;i++)
_DestroyListItem(&Ptr[i]);
if (Ptr)
FreePtr((void *)Ptr);
Ptr=NULL;
ItemsAlloced=Items=0;
}
void MEMBLOCK::SetSize(int len){
if(!len){
FreePtr(Ptr);
Ptr=NULL;
} else
ResizePtr(&Ptr,len);
Len=len;
}
CBin::t_size CBin::LShift( CBin::t_size x_nBytes )
{_STT();
// Anything to do?
if ( !x_nBytes && !m_nOffset )
return 0;
// All of it?
if ( x_nBytes >= getUsed() )
{ FreePtr();
return 0;
} // end if
// Account for the offset
x_nBytes += m_nOffset;
m_nOffset = 0;
// Are we doing any work?
if ( !x_nBytes )
return m_nUsed;
// Copy Ptr buffer if needed
if ( m_ptr )
{
// What's the new size?
m_nUsed -= x_nBytes;
if ( !m_buf.OexNew( m_nUsed ).Ptr() )
return 0;
// Copy to private buffer
m_buf.MemCpy( &m_ptr[ x_nBytes ], m_nUsed );
} // end if
else
{
// Just shift the buffer
m_buf.LShift( x_nBytes, m_nUsed - x_nBytes ),
m_nUsed -= x_nBytes;
} // end else
return m_nUsed;
}
OEX_USING_NAMESPACE
const CBin::t_byte* CBin::Resize( CBin::t_size x_nNewSize )
{_STT();
// Ptr buffer?
if ( m_ptr )
{
// Is the buffer just getting smaller?
if ( m_nUsed > x_nNewSize )
m_nUsed = x_nNewSize;
// Must allocate more space
else
{
// Make a new buffer and copy data
if ( !m_buf.OexNew( x_nNewSize ).Ptr() )
return 0;
// Remember how many are used
t_size nUsed = m_nUsed;
// Copy the data
oexMemCpy( m_buf.Ptr(), m_ptr, nUsed );
// Free the user pointer
FreePtr();
// Restore used amount
m_nUsed = nUsed;
} // end else
} // end if
// Simple resize
else
m_buf.OexResize( x_nNewSize );
// How did it go?
return Ptr();
}
CBin::t_size CBin::AppendBuffer( const CBin::t_byte *x_pBuf, CBin::t_size x_nBytes )
{_STT();
// Null Append?
if ( !x_pBuf || !x_nBytes )
return m_nUsed;
// Ptr pointer?
if ( m_ptr )
{
// Remember how many bytes are being used
t_size nUsed = m_nUsed;
// Copy Ptr buffer
if ( nUsed )
m_buf.MemCpy( m_ptr, nUsed );
// Append new data
m_buf.MemCpyAt( (t_byte*)x_pBuf, nUsed, x_nBytes );
// No Ptr buffer anymore
FreePtr();
// New used amount
m_nUsed = nUsed + x_nBytes;
return m_nUsed;
}
// Verify m_nUsed
if ( (unsigned int)m_nUsed > m_buf.Size() )
m_nUsed = m_buf.Size();
// Append new data
m_buf.MemCpyAt( (t_byte*)x_pBuf, m_nUsed, x_nBytes );
m_nUsed += x_nBytes;
return m_nUsed;
}
CBin::t_size CBin::Share( CBin *x_p )
{_STT();
if ( !x_p || !x_p->getUsed() )
{ Destroy();
return 0;
} // end if
// Lose any Ptr buffer
FreePtr();
// Ptr buffer?
if ( x_p->m_ptr )
setBuffer( x_p->m_ptr, x_p->m_nUsed, x_p->m_nOffset, x_p->m_bFree );
// Share native buffer
else
m_nUsed = x_p->m_nUsed,
m_nOffset = x_p->m_nOffset,
m_buf.Share( x_p->m_buf );
return m_nUsed;
}
// Generic free memory
void CMSEXPORT _cmsFree(cmsContext ContextID, void* Ptr)
{
if (Ptr != NULL) FreePtr(ContextID, Ptr);
}
void Micropolis::destroyMapArrays()
{
if (mapPtr) {
FreePtr(mapPtr);
mapPtr = NULL;
}
memset(Map, 0, sizeof(short *) * WORLD_X);
if (popPtr) {
FreePtr(popPtr);
popPtr = NULL;
}
if (trfPtr) {
FreePtr(trfPtr);
trfPtr = NULL;
}
if (polPtr) {
FreePtr(polPtr);
polPtr = NULL;
}
if (landPtr) {
FreePtr(landPtr);
landPtr = NULL;
}
if (crimePtr) {
FreePtr(crimePtr);
crimePtr = NULL;
}
if (tem1Base) {
FreePtr(tem1Base);
tem1Base = NULL;
}
if (tem2Base) {
FreePtr(tem2Base);
tem2Base = NULL;
}
auxPopPtr = NULL;
auxTrfPtr = NULL;
auxPolPtr = NULL;
auxLandPtr = NULL;
auxCrimePtr = NULL;
memset(PopDensity, 0, sizeof(Byte *) * HWLDX);
memset(TrfDensity, 0, sizeof(Byte *) * HWLDX);
memset(PollutionMem, 0, sizeof(Byte *) * HWLDX);
memset(LandValueMem, 0, sizeof(Byte *) * HWLDX);
memset(CrimeMem, 0, sizeof(Byte *) * HWLDX);
memset(tem, 0, sizeof(Byte *) * HWLDX);
memset(tem2, 0, sizeof(Byte *) * HWLDX);
memset(tem2, 0, sizeof(Byte *) * HWLDX);
brettPtr = NULL;
if (terrainBase) {
FreePtr(terrainBase);
terrainBase = NULL;
}
if (qTemBase) {
FreePtr(qTemBase);
qTemBase = NULL;
}
memset(TerrainMem, 0, sizeof(Byte *) * QWX);
memset(Qtem, 0, sizeof(Byte *) * QWX);
if (ResHis) {
FreePtr(ResHis);
ResHis = NULL;
}
if (ComHis) {
FreePtr(ComHis);
ComHis = NULL;
}
if (IndHis) {
FreePtr(IndHis);
IndHis = NULL;
}
if (MoneyHis) {
FreePtr(MoneyHis);
MoneyHis = NULL;
}
if (PollutionHis) {
FreePtr(PollutionHis);
PollutionHis = NULL;
}
if (CrimeHis) {
FreePtr(CrimeHis);
CrimeHis = NULL;
}
if (MiscHis) {
FreePtr(MiscHis);
MiscHis = NULL;
}
if (PowerMap) {
FreePtr(PowerMap);
PowerMap = NULL;
}
}
