xb.c

个人日程管理系统

	}
} //ExtraChunkHeadType*
//TaskFindExtraChunkHead(ExtraChunkHeadType const* block,
//					   UInt8 type, UInt8 subkey)





/****************************************************************************
 * Name : TaskGetExtraChunkV022
 * Desc : get chunk data of extra block
 * Prm  : 
 * 			-> database ptr
 * 			-> index
 * 			-> chunk type
 *          -> subkey
 * 			-> buffer ptr
 * 			-> size ptr
 * Out  : retrieve body to dest if not NULL and chunk is found.
 *        set *size to chunk size in bytes.
 *        return pgOK if chunk was found and buffer size is enoth, 
 *        otherwith return pgError.
 * Auth : seagull, 27,09,2000
 * XXX  : DEPRECATED
 ***************************************************************************/
pgErr TaskGetExtraChunkV022(DmOpenRef dbP, UInt16 index, UInt8 type, 
	UInt8 subkey, MemPtr dest, UInt16* size/*in bytes*/)
{
	MemHandle hTask = DmQueryRecord(dbP, index);
	pgErr err = TaskGetExtraChunkByTaskPtrV022(
		(TaskExtendedRecordType*)MemHandleLock(hTask),
		type, subkey, dest, size);

	MemHandleUnlock(hTask);
	return err;
}//pgErr TaskGetExtraChunkV022(DmOpenRef dbP, UInt16 index, UInt8 type, UInt8 subkey
//						MemPtr dest, UInt16* size/*in bytes*/)



/****************************************************************************
 * Name : TaskGetExtraChunk
 * Desc : get chunk data of extra block
 * Prm  : 
 * 			-> database ptr
 * 			-> index
 * 			-> chunk type
 *          -> subkey
 * 			-> buffer ptr
 * 			-> size ptr
 * Out  : retrieve body to dest if not NULL and chunk is found.
 *        set *size to chunk size in bytes.
 *        return pgOK if chunk was found and buffer size is enoth, 
 *        otherwith return pgError.
 * Auth : seagull, 27,09,2000
 ***************************************************************************/
pgErr TaskGetExtraChunk(DmOpenRef dbP, UInt16 index, UInt8 type, UInt8 subkey,
						MemPtr dest, UInt16* size/*in bytes*/)
{
	MemHandle hTask = DmQueryRecord(dbP, index);
	pgErr err = TaskGetExtraChunkByTaskPtr(
		(TaskExtendedRecordType*)MemHandleLock(hTask),
		type, subkey, dest, size);

	MemHandleUnlock(hTask);
	return err;
}//pgErr TaskGetExtraChunk(DmOpenRef dbP, UInt16 index, UInt8 type, UInt8 subkey
//						MemPtr dest, UInt16* size/*in bytes*/)




/****************************************************************************
 * Name : TaskGetExtraChunkByTaskPtrV022
 * Desc : get chunk data of extra block
 * Prm  : 
 * 			-> Task ptr
 * 			-> chunk type
 *          -> subkey
 * 			-> buffer ptr
 * 			-> size ptr
 * Out  : retrieve body to dest if not NULL and chunk is found.
 *        set *size to chunk size in bytes.
 *        return pgOK if chunk was found and buffer size is enough, 
 *        otherwith return pgError.
 * Auth : seagull, 27,09,2000
 * XXX  : DEPRECATED, used in db conversion
 ***************************************************************************/
pgErr TaskGetExtraChunkByTaskPtrV022(TaskExtendedRecordType* pTask,
								 UInt8 type, UInt8 subkey,
								 MemPtr dest, UInt16* size/*in bytes*/)
{
	pgErr err = pgError;
	ExtraChunkHeadType* pChunk = 
		(ExtraChunkHeadType*)TaskGetExtraBlockHeadPtr(pTask);

	if ((MemPtr)pTask + MemPtrSize(pTask) - (MemPtr)pChunk
		> sizeof(ExtraChunkHeadType) * 2)
	{
		pChunk = TaskFindExtraChunkHead(pChunk, type, subkey);
		if (pChunk != NULL && size != NULL)
		{
			if (dest != NULL && pChunk->size <= *size)
			{
				MemMove(dest, pChunk->body, pChunk->size);
				err = pgOK;
			}
			*size = pChunk->size;
		}
		else if (size == NULL)
			err = pgOK; // return exist/non exist status only.
	}

	return err;
} //pgErr TaskGetExtraChunkByTaskPtrV022(TaskExtendedRecordType* pTask,
//								 UInt8 type, UInt8 subkey,
//								 MemPtr dest, UInt16* size/*in bytes*/)




/****************************************************************************
 * Name : TaskGetExtraChunkByTaskPtr
 * Desc : get chunk data of extra block
 * Prm  : 
 * 			-> Task ptr
 * 			-> chunk type
 *          -> subkey
 * 			-> buffer ptr
 * 			-> size ptr
 * Out  : retrieve body to dest if not NULL and chunk is found.
 *        set *size to chunk size in bytes.
 *        return pgOK if chunk was found and buffer size is enough, 
 *        otherwith return pgError.
 * Auth : seagull, 27,09,2000
 * Mod	: lb, 2001-09-08
 * 		  	adapt to 0.23 db format
 ***************************************************************************/
pgErr TaskGetExtraChunkByTaskPtr(TaskExtendedRecordType* pTask,
								 UInt8 type, UInt8 subkey,
								 MemPtr dest, UInt16* size/*in bytes*/)
{
	pgErr err = pgError;
	// data is an array, so XB.data is an address (UInt8*)
	ExtraChunkHeadType* pChunk = (ExtraChunkHeadType*)(pTask->fields.XB.data);

	pChunk = TaskFindExtraChunkHead(pChunk, type, subkey);
	if (pChunk != NULL && size != NULL)
	{
		if (dest != NULL && pChunk->size <= *size)
		{
			MemMove(dest, pChunk->body, pChunk->size);
			err = pgOK;
		}
		*size = pChunk->size;
		DBGMSG((DBB, "In TaskGetExtraChunkByTaskPtr"));
		DBGMSG((DBB, "Complete record next line"));
		DBGMSGBIN((DBB, pTask, MemPtrSize(pTask)));
		DBGMSG((DBB, "ExtraChunk size %hu next line", *size));
		DBGMSGBIN((DBB, pChunk->body, *size));

	}
	else if (size == NULL)
		err = pgOK; // return exist/non exist status only.

	return err;
} //pgErr TaskGetExtraChunkByTaskPtr(TaskExtendedRecordType* pTask,
//								 UInt8 type, UInt8 subkey,
//								 MemPtr dest, UInt16* size/*in bytes*/)




/****************************************************************************
 * Name : TaskRemoveExtraChunk
 * Desc : remove chunk and compaction extra block.
 * Prm  : 
 * 			-> databse ptr
 * 			-> index
 * 			-> chunk type
 * 			-> subkey
 * Out  : 
 * Auth : seagull, 27,09,2000
 ***************************************************************************/
void TaskRemoveExtraChunk(DmOpenRef dbP, UInt16 index,
						  UInt8 type, UInt8 subkey)
{
	ExtraChunkHeadType* pChunk;
	UInt8* pExtra;

	UInt32 sizeExtra = TaskGetExtraBlock(dbP, index, NULL);
	if (! sizeExtra) return ; // no bloc

	pExtra = MemPtrNew(sizeExtra);
	TaskGetExtraBlock(dbP, index, pExtra);

	pChunk = TaskFindExtraChunkHead((ExtraChunkHeadType*)pExtra,
									type, subkey);
	if (pChunk) 
	{   // found it, go to compaction
		UInt8* src = (UInt8*)NextChunk(pChunk);
		UInt8* dst = (UInt8*)pChunk;
		UInt16 sizeChunk = (UInt8*)src - (UInt8*)pChunk;
		DBGMSG((DBB, "Removing a chunk"));

		if (((ExtraChunkHeadType*)src)->type == Extra_NULL &&
			dst == pExtra)
		{  // Extra block is empty. delete it
			TaskSetExtraBlock(dbP, index, NULL, 0);
		}
		else
		{
			while (src < pExtra + sizeExtra)
				*dst++ = *src++;
			TaskSetExtraBlock(dbP, index, pExtra, sizeExtra - sizeChunk);
		}
	}

	MemPtrFree(pExtra);
}//void TaskRemoveExtraChunk(DmOpenRef dbP, UInt16 index,
//						  UInt8 type, UInt8 subkey)



/****************************************************************************
 * Name : TaskSetExtraChunk
 * Desc : 
 * Prm  : 
 * 			-> database ptr
 * 			-> index
 * 			-> chunk type
 * 			-> source buffer
 * 			-> chunk size
 * Out  : 
 * Auth : seagull, 27,09,2000
 ***************************************************************************/
pgErr    TaskSetExtraChunk(DmOpenRef dbP, UInt16 index,
                           UInt8 type, UInt8 subkey,
						   MemPtr src, UInt16 size)
{
	// TODO: reuse block if type, subkey and size is equal.

	MemPtr pExtra = NULL;
	UInt16 sizeExtra;
	ExtraChunkHeadType* pChunk = NULL;
	Boolean bCreateNew = true;

	TaskRemoveExtraChunk(dbP, index, type, subkey);

	sizeExtra = TaskGetExtraBlock(dbP, index, NULL);
	if (sizeExtra)
	{
		pExtra = MemPtrNew(sizeExtra + sizeof(ExtraChunkHeadType) + size);
		if (! pExtra) return pgError;
		TaskGetExtraBlock(dbP, index, pExtra);

		pChunk = TaskFindExtraChunkHead((ExtraChunkHeadType*)pExtra,
										Extra_NULL, 0);
		if (pChunk)
			bCreateNew = false;
		else
		{
			MemPtrFree(pExtra);
			DEBUG1("Extra chunk was broken. Deleted");
		}
	}

	if (bCreateNew)
	{   // *2 is itself and null chunk
		pExtra = MemPtrNew(sizeof(ExtraChunkHeadType) * 2 + size);
		if (! pExtra) return pgError;
		pChunk = pExtra;
	}

	// make new chunk
	pChunk->type = type;
	pChunk->subkey = subkey;
	pChunk->reserve1 = 0;
	pChunk->size = size;
	MemMove(pChunk->body, src, size);

	// make new sentinel
	pChunk = NextChunk(pChunk);
	pChunk->type = Extra_NULL;
	pChunk->subkey = 0;
	pChunk->reserve1 = 0;
	pChunk->size = 0;

	TaskSetExtraBlock(dbP, index, pExtra, MemPtrSize(pExtra));
	MemPtrFree(pExtra);

	return pgOK;
}