bs_base.h

可串行化的基类对象

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

  FileName: BS_BASE.H

  Autor: Betao ([e-mail], [e-mail])


  S鉶 Paulo 24 de janeiro de 2000

  Objeto base utilizado na serializa玢o de todos os membros de uma classe.,
  inclusive os membros das classes derivadas.

  _BS_MEMBER_ - estrutura repons醰el para o armazenameto do membro do objeto
  _BS_OBJ_    - objeto gen閞ico base

  ----------------------------------------
  01/24/2000

  Base object to serialize all class磗 members an derived class members.

  _BS_MEMBER_ - member structure 

  Data Members:

	BS_SIZE m_nSize ; // size of data
	void *  m_pData ; // data
	
  Methods:
	
	              _BS_MEMBER_(); // constructor just init members
	             ~_BS_MEMBER_(); // destructor to free unhandled data
	void          Reset()      ; // reset the data
	void          SetData(void * data, BS_SIZE size);// set the data, copy the received data to prevent access violation
	const void  * GetData()    ; // get the data
	BS_SIZE       GetDataSize(); // get the data size
	
  
	----------------------------------		
	  _BS_OBJ_    - base object

  Data Members:

    _BS_MEMBER_   m_aMembers[BS_MAXMEMBERS]; // members
	unsigned int  m_iMembersCount          ; // number of used members
	BS_ID         m_ID                     ; // id of the strucure ( used for serialization )
	BS_BYTE  *    m_pSerializedData        ; // pointer to hold de serialized data (preventing invalid pointers)


  Methods:

	             _BS_OBJ_(void * pData = NULL) ;// constructor
	            ~_BS_OBJ_()                    ;// destructor .. free the serialize data pointer
	void         SetID(BS_ID id)               ;// sets the object磗 id
	BS_ID        GetID()                       ;// gets the object磗 id
	unsigned int AddMember()                   ;// use a new member (alway on the bottom)
	unsigned int RemoveMember()                ;// "inutilize" the bottom member
	unsigned int GetMemberCount()              ;// gets the number of members
	void         ResetMembers()                ;// reset em structure members
	const void * GetMemberData(unsigned int index) ;// gets the data from the holder
	BOOL         SetMemberData(unsigned int index, void * pData, BS_SIZE size) ;// sets the data 
	void         ResetSerializedData(BS_SIZE size = 0);// resets de serialized data
	BS_SIZE      GetSize()                     ;// gets the size of all data in the struct ( used for serialization )
	void *       GetSerialBuffer(BS_SIZE size) ;// return the buffer pointer
	void         ReleaseSerialBuffer()         ;// release the serialized data
	BS_SIZE      Serialize(void ** pBuffer)    ;// serialize all holded data in the buffer
	BOOL         Deserialize()                 ;// deserialize received data
	BOOL         Deserialize(void * pData)     ;// if you already have a serialized data buffer


*****************************************************************************
*/
#if !defined(__BS_BASE_H_DEFINED)
#define __BS_BASE_H_DEFINED

////////////////////////////////////////////
//  includes

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>


// just in case of 
#ifndef NULL
   #define NULL 0L
#endif//NULL

#ifndef BOOL
   #define BOOL char
   #define TRUE 1
   #define FALSE 1
#endif

// invalid struct ID
#define BS_NOSTRUCT ((BS_ID)-1)
#define BS_ERROR    ((unsigned int) -1)
//  max number of members
#define BS_MAXMEMBERS 50

//////////////////////////////////////////////////////
// basic types 
typedef unsigned char      BS_BYTE;

// identification
typedef unsigned short int BS_ID  ;

// size
typedef unsigned long int BS_SIZE;

//////////////////////////////////////////////////////
// strcture to hold member information
struct _BS_MEMBER_
{
private:
	BS_SIZE m_nSize ; // size of data
	void *  m_pData ; // data
	
public:
	
	// constructor just init members
	_BS_MEMBER_();
	
	// destructor to free unhandled data
	~_BS_MEMBER_() ;
	
	// reset the data
	void Reset();
	
	// set the data, copy the received data to prevent access violation
	void SetData(void * data, BS_SIZE size);
	
	// get the data
	const void  * GetData();    
	
	// get the data size
	BS_SIZE GetDataSize();
	
};


///////////////////////////////////////////////
//  base class for a generic object
class _BS_OBJ_
{
	
private:
	// members
	_BS_MEMBER_ m_aMembers[BS_MAXMEMBERS];
	
	// number of used members
	unsigned int m_iMembersCount;
	
	// id of the strucure ( used for serialization )
	BS_ID  m_ID;
	
	// pointer to hold de serialized data (preventing invalid pointers)
	BS_BYTE  * m_pSerializedData;
	
	
	///////////////////////////////////////
	////   functions
	
protected:
	// sets the object磗 id
	void  SetID(BS_ID id) ;
	
	// gets the object磗 id
	BS_ID GetID() ;
	
	// use a new member (alway on the bottom)
	unsigned int AddMember() ;
	
	// "inutilize" the bottom member
	unsigned int RemoveMember() ;
	
	// gets the number of members
	unsigned int GetMemberCount();
	
	// reset em structure members
	void ResetMembers();
	
	// gets the data from the holder
	const void * GetMemberData(unsigned int index) ;
	
	// sets the data 
	BOOL SetMemberData(unsigned int index, void * pData, BS_SIZE size) ;
	
	// resets de serialized data
	void ResetSerializedData(BS_SIZE size = 0);
	
public:
	// constructor
	_BS_OBJ_(void * pData = NULL) ;
	
	// destructo .. free the serialize data pointer
	~_BS_OBJ_() ;
	
	// gets the size of all data in the struct ( used for serialization )
	BS_SIZE GetSize();
	
	// return the buffer pointer
	void * GetSerialBuffer(BS_SIZE size) ;
	
	// release the serialized data
	void ReleaseSerialBuffer() ;
	
	// serialize all holded data in the buffer
	BS_SIZE Serialize(void ** pBuffer) ;
	
	// deserialize received data
	BOOL Deserialize();
	
	// if you already have a serialized data buffer
	BOOL Deserialize(void * pData);
	
};



//////////////////////////////////////
///  _BS_MEMBER_

_BS_MEMBER_::_BS_MEMBER_():
m_nSize(0), 
m_pData(NULL) 
{
}

_BS_MEMBER_::~_BS_MEMBER_() 
{ 
	// free data pointer
	Reset();
}

void _BS_MEMBER_::Reset()
{
	// no size
	m_nSize = 0;
	
	// check and free the data pointer
	if(m_pData != NULL) 
		free(m_pData);
	
	m_pData = NULL;
}

void _BS_MEMBER_::SetData(void * data, BS_SIZE size)
{
	//  clean
	Reset();
	
	// if received a invalid data, this data will be invalid 
	if(data == NULL) 
		return;
	
	// get a new pointer to hold the data
	m_pData = malloc(size);
	
	// just in case of insuficient fault 
	if(m_pData == NULL) 
		return;
	
	// copy the new data
	memcpy(m_pData, data, size ); 
	m_nSize = size;
}

const void  * _BS_MEMBER_::GetData()    
{ 
	// gets data pointer
	return m_pData; 
}

BS_SIZE _BS_MEMBER_::GetDataSize()
{ 
	// gets size
	return m_nSize ; 
}

//////////////////////////////////////
///  _BS_OBJ_
_BS_OBJ_::_BS_OBJ_(void * pData) :
m_ID             (BS_NOSTRUCT),
m_pSerializedData(NULL),
m_iMembersCount  (0) 
{
	// check pointer and deserialize
	if(pData != NULL) 
		Deserialize(pData);
}

_BS_OBJ_::~_BS_OBJ_() 
{ 
	// free the serial data internal buffer
	ResetSerializedData();
}

void  _BS_OBJ_::SetID(BS_ID id) 
{ 
	// identify the object
	m_ID = id; 
}

BS_ID _BS_OBJ_::GetID()         
{ 
	// identify the object
	return m_ID; 
}

unsigned int _BS_OBJ_::AddMember()     
{ 
	// increase matrix limit
	m_iMembersCount++;

	// check matrix limit
	if(m_iMembersCount >= BS_MAXMEMBERS)
	{
		m_iMembersCount--;
		return BS_ERROR;
	}

	return m_iMembersCount;
}


unsigned int _BS_OBJ_::GetMemberCount()
{ 
	return m_iMembersCount;  
}


unsigned int _BS_OBJ_::RemoveMember() 
{ 
	// reset the member	and inutilize holder
	m_aMembers[--m_iMembersCount].Reset();
	
	return m_iMembersCount;
}


void _BS_OBJ_::ResetMembers()
{
	// reset all members
	for(int x = 0; x < BS_MAXMEMBERS; x++)
		m_aMembers[x].Reset();
	m_iMembersCount = 0;

}

const void * _BS_OBJ_::GetMemberData(unsigned int index)
{
	// check index
	if (index < m_iMembersCount) 
		return m_aMembers[index].GetData();
	else 
		return NULL;
}

BOOL _BS_OBJ_::SetMemberData(unsigned int index, void * pData, BS_SIZE size)
{
	// check index
	if ((index > m_iMembersCount) | (pData == NULL) | (size == 0)) 
		return FALSE;

	// set member
	m_aMembers[index].SetData(pData, size);
	return TRUE;
}


void _BS_OBJ_::ResetSerializedData(BS_SIZE size )
{
	// check and free
    if(m_pSerializedData != NULL)	
		free(m_pSerializedData);
	
	// check if u need a empty room 
	if(size > 0)
	{
		// alloc memory
		m_pSerializedData = (BS_BYTE *) malloc(size);
		
		// check pointer and initialize 
		if(m_pSerializedData != NULL) 
			memset(m_pSerializedData, '\0', size);
	}
	else
		m_pSerializedData = NULL;
}


BS_SIZE _BS_OBJ_::GetSize()
{
	// gets the id size
	BS_SIZE size = sizeof(m_ID);
	
	// gets all members size and the size of all data holded
	for(unsigned int x=0; x < m_iMembersCount; x++) 
		size += (sizeof(BS_SIZE) + m_aMembers[x].GetDataSize());
	return size;
}

void * _BS_OBJ_::GetSerialBuffer(BS_SIZE size)
{
	// clean the pointer and make a room the hold new serialized data
	ResetSerializedData(size);
	return m_pSerializedData;
}


void _BS_OBJ_::ReleaseSerialBuffer() 
{ 
	// free the buffer磗 memory
	ResetSerializedData((BS_SIZE)0); 
}


// serialize all holded data 
BS_SIZE _BS_OBJ_::Serialize(void ** pBuffer)
{
	// clean the pointer and make a room the hold new serialized data
	ResetSerializedData(GetSize());
	
	// aux磗
	unsigned int x;
	BS_SIZE      size;
	BS_BYTE *    aux = m_pSerializedData;
	
	// save the id first
	aux  = (BS_BYTE *) memcpy((void*)m_pSerializedData,(void*)&m_ID, sizeof(BS_ID));
	aux += sizeof(BS_ID);
	
	for(x=0; x < m_iMembersCount; x++)
	{
		
		// save the data size
		size = m_aMembers[x].GetDataSize();
		aux  = (BS_BYTE *)memcpy((void*)aux,&size, sizeof(BS_SIZE));
		aux += sizeof(BS_SIZE);
		
		// save the data
		aux  = (BS_BYTE*)memcpy((void*)aux, m_aMembers[x].GetData(), m_aMembers[x].GetDataSize());
		aux += m_aMembers[x].GetDataSize();
	}

	// give access to internal buffer	
	*pBuffer = m_pSerializedData;
	
	// return the size and hold data until derived class releases it
	return GetSize();
}

// deserialize received data
BOOL _BS_OBJ_::Deserialize()
{
	// be sure you have data to deserialize
	if(m_pSerializedData == NULL) return FALSE;
	
	// aux磗
	BS_BYTE * aux = (BS_BYTE *) m_pSerializedData;
	BS_ID     id;
	BS_SIZE   size;
	
	// gets and check the structure磗 id
	memcpy(&id, aux, sizeof(BS_ID));
		  
	// if data is not this type
	if(id != m_ID) return FALSE;
		  
	// atualize pointer
	aux += sizeof(BS_ID);
		  
	// get all data
	for(unsigned int x=0; x < m_iMembersCount; x++)
	{
		// if something goes wrong
		if(! aux ) 
		{
			ResetMembers();
			return FALSE;
		}
		
		// get the data size
		memcpy(&size, aux, sizeof(BS_SIZE));
		// atualize pointer
		aux += sizeof(BS_SIZE);
		
		// add member
		SetMemberData(x,aux, size) ;
		// atualize pointer
		aux += size;
		
	}
	
	// object is ok
	return TRUE;
}

// if you already have a serialize data buffer
BOOL _BS_OBJ_::Deserialize(void * pData)
{
	// get the data pointer
	m_pSerializedData =(BS_BYTE*)  pData;
	
	// deserialize members
	BOOL ret = Deserialize();
	
	// loose the pointer to prevent invalid pointer when object is destroyed
	m_pSerializedData = NULL;
	
	return ret;
}



#endif // __BS_BASE_H_DEFINED