示例#1
0
//////////////////////////////////////////////////////////////////////////
//																		//
//																		//
//////////////////////////////////////////////////////////////////////////
CMemoryFile* MemoryFile(void* pvInitialMem, int iInitialLength)
{
	CMemoryFile*	pcMemoryFile;

	pcMemoryFile = NewMalloc<CMemoryFile>();
	pcMemoryFile->Init(pvInitialMem, iInitialLength);
	pcMemoryFile->mbBasicFileMustFree = TRUE;
	return pcMemoryFile;
}
示例#2
0
//////////////////////////////////////////////////////////////////////////
//																		//
//																		//
//////////////////////////////////////////////////////////////////////////
CMemoryFile* MemoryFile(void)
{
	CMemoryFile* pcMemoryFile;

	pcMemoryFile = NewMalloc<CMemoryFile>();
	pcMemoryFile->Init();
	pcMemoryFile->mbBasicFileMustFree = TRUE;
	return pcMemoryFile;
}
void TestLogFileCommandsSimple(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iInt;
	int				iWritten;
	int				iResult;
	int				iRead;

	pcMemoryFile = MemoryFile();
	pcLogFile = LogFile(pcMemoryFile);
	cFile.Init(pcLogFile);

	pcLogFile->Begin();

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);
	AssertTrue(cFile.IsOpen());

	iInt = 872349342;
	iWritten = (int)cFile.Write(&iInt, sizeof(int), 1);
	AssertInt(1, iWritten);
	AssertInt(0, pcMemoryFile->GetBufferSize());

	bResult = cFile.Close();
	AssertTrue(bResult);
	AssertInt(3, pcLogFile->GetNumCommands());

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);
	AssertTrue(cFile.IsOpen());
	AssertInt(sizeof(int), (int)cFile.GetFileLength());
	iRead = (int)cFile.Read(&iResult, sizeof(int), 1);
	AssertInt(1, iRead);
	AssertInt(iInt, iResult);
	bResult = cFile.Close();
	AssertTrue(bResult);
	AssertInt(5, pcLogFile->GetNumCommands());

	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertFalse(pcMemoryFile->IsOpen());
	AssertInt(sizeof(int), pcMemoryFile->GetBufferSize());
	AssertInt(iInt, *((int*)pcMemoryFile->GetBufferPointer()));

	pcLogFile->Kill();
}
示例#4
0
void test_MemoryFile()
{
    CMemoryFile memFile;
    BYTE s1[] = "12345";
    BYTE s2[] = "aaaaaaaa";
    DWORD dwNum = 5;
    memFile.WriteFile(s1, dwNum, &dwNum);
    cout<< dwNum << endl;

    dwNum = 8;
    memFile.WriteFile(s2, dwNum, &dwNum);
    cout<< dwNum << endl;

    BYTE s3[1024] = { 0 };
    DWORD dwRead = 1024;
    memFile.SetFilePointer(0, FILE_BEGIN);
    memFile.ReadFile(s3, dwRead, &dwRead);
    cout<< (char *)s3 << dwRead << endl;
}
void TestLogFileCommandsComplex(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iWritten;
	char			szABC[] = {"ABCDEFGHIJK"};
	char			sz123[] = {"123"};
	char			sz4[] = {"4"};
	char			szExclamation[] = {"!?"};
	char			szQWE[] = {"_QWE_"};
	char			szResult[12];

	pcMemoryFile = MemoryFile();
	pcMemoryFile->Open(EFM_ReadWrite_Create);
	pcMemoryFile->Write(szABC, 1, 12);
	pcMemoryFile->Close();

	pcLogFile = LogFile(pcMemoryFile);
	cFile.Init(pcLogFile);

	pcLogFile->Begin();

	cFile.Open(EFM_ReadWrite_Create);
	AssertInt(12, (int)cFile.GetFileLength());

	iWritten = (int)cFile.Write(sz123, 1, 3);
	AssertInt(3, iWritten);
	iWritten = (int)cFile.Write(sz4, 1, 1);
	AssertInt(1, iWritten);
	cFile.Close();

	cFile.Open(EFM_ReadWrite_Create);
	cFile.Write(szExclamation, 1, 2);
	cFile.Seek(3, EFSO_CURRENT);
	cFile.Write(szQWE, 5, 1);
	cFile.Close();

	cFile.Open(EFM_Read);
	AssertInt(12, (int)cFile.GetFileLength());
	memset(szResult, 0, 12);
	cFile.Read(szResult, 12, 1);
	AssertString("!?34E_QWE_K", szResult);
	cFile.Close();
	
	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertFalse(pcMemoryFile->IsOpen());
	AssertInt(12, pcMemoryFile->GetBufferSize());
	AssertString("!?34E_QWE_K", (char*)pcMemoryFile->GetBufferPointer());

	pcLogFile->Kill();
}
void TestLogFileWrite(void)
{
	CLogFile*		pcLogFile;
	CMemoryFile*	pcMemoryFile;
	CFileBasic		cFile;
	BOOL			bResult;
	int				iLength;
	char			sz[200];

	pcMemoryFile = MemoryFile();
	pcLogFile = LogFile(pcMemoryFile);
	cFile.Init(pcLogFile);

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);

	bResult = cFile.WriteString("The suspense is killing me!");
	AssertTrue(bResult);
	AssertNull((char*)pcMemoryFile->GetBufferPointer());
	
	AssertInt(1, pcLogFile->GetNumWrites());
	AssertLongLongInt(32, pcLogFile->GetWriteSize(0));

	bResult = cFile.Seek(8);
	AssertTrue(bResult);

	bResult = cFile.WriteData("camisole", 8);
	AssertTrue(bResult);
	AssertInt(1, pcLogFile->GetNumWrites());
	AssertLongLongInt(32, pcLogFile->GetWriteSize(0));
	
	AssertNull((char*)pcMemoryFile->GetBufferPointer());
	cFile.Seek(0);
	bResult = cFile.ReadStringLength(&iLength);
	AssertTrue(bResult);
	AssertInt(28, iLength);
	AssertFalse(cFile.IsEndOfFile());
	bResult = cFile.ReadStringChars(sz, iLength);
	AssertString("The camisole is killing me!", sz);
	AssertTrue(cFile.IsEndOfFile());

	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertString("The camisole is killing me!", (char*)RemapSinglePointer(pcMemoryFile->GetBufferPointer(), sizeof(int)));

	bResult = cFile.Close();  //This should go before Commit
	AssertTrue(bResult);

	pcLogFile->Begin();
	
	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);

	bResult = cFile.Seek(4);
	AssertTrue(bResult);
	bResult = cFile.WriteData("Dog", 3);

	bResult = cFile.Seek(20);
	AssertTrue(bResult);
	bResult = cFile.WriteData("plurgle", 7);

	AssertInt(2, pcLogFile->GetNumWrites());
	AssertLongLongInt(3, pcLogFile->GetWriteSize(0));
	AssertLongLongInt(7, pcLogFile->GetWriteSize(1));

	AssertString("The camisole is killing me!", (char*)RemapSinglePointer(pcMemoryFile->GetBufferPointer(), sizeof(int)));
	cFile.Seek(0);
	bResult = cFile.ReadStringLength(&iLength);
	AssertTrue(bResult);
	AssertInt(28, iLength);
	AssertFalse(cFile.IsEndOfFile());
	bResult = cFile.ReadStringChars(sz, iLength);
	AssertTrue(bResult);
	AssertString("Dog camisole is plurgle me!", sz);
	AssertTrue(cFile.IsEndOfFile());

	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertString("Dog camisole is plurgle me!", (char*)RemapSinglePointer(pcMemoryFile->GetBufferPointer(), sizeof(int)));

	bResult = cFile.Close();
	AssertTrue(bResult);

	pcLogFile->Begin();

	bResult = cFile.Open(EFM_ReadWrite_Create);
	AssertTrue(bResult);

	cFile.Seek(4);
	cFile.WriteData("X", 1);
	cFile.Seek(6);
	bResult = cFile.WriteData("Z", 1);
	cFile.Seek(28);
	cFile.WriteData("A", 1);
	cFile.Seek(30);
	bResult = cFile.WriteData("C", 1);
	AssertInt(4, pcLogFile->GetNumWrites());

	cFile.Seek(5);
	cFile.WriteData("Y", 1);
	AssertInt(3, pcLogFile->GetNumWrites());
	
	cFile.Seek(29);
	cFile.WriteData("B", 1);
	AssertInt(2, pcLogFile->GetNumWrites());

	cFile.Seek(0);
	bResult = cFile.ReadStringLength(&iLength);
	AssertTrue(bResult);
	bResult = cFile.ReadStringChars(sz, iLength);
	AssertString("XYZ camisole is plurgle ABC", sz);
	AssertTrue(cFile.IsEndOfFile());

	bResult = pcLogFile->Commit();
	AssertTrue(bResult);
	AssertString("XYZ camisole is plurgle ABC", (char*)RemapSinglePointer(pcMemoryFile->GetBufferPointer(), sizeof(int)));

	bResult = cFile.Close();
	AssertTrue(bResult);

	cFile.Kill();
}
BOOL CTileMapXML::ImportTiles(CMarkupTag* pcTag, CTileLayer* pcLayer)
{
	CChars				szCSV;
	CCSVFileImmutable	cCSVFile;
	CMemoryFile			cMemoryFile;
	int					iRow;
	SCSVRowImmutable*	psRow;
	int					i;
	char*				szCelIndex;
	CTextParser			cTextParser;
	TRISTATE			tResult;
	int					iCelIndex;
	CChars				szError;
	CTile*				pcTile;

	szCSV.Init(128);
	pcTag->GetText(&szCSV);
	if (szCSV.Empty())
	{
		szCSV.Kill();
		CMarkupTextParser::LogErrorTagWasEmpty(pcTag);
		return FALSE;
	}

	szCSV.StripWhiteSpace(TRUE);
	//szCSV.Replace(" ", "");  //Write a test for this, why does it not work?

	cMemoryFile.Init(szCSV.Text(), szCSV.Length());

	cCSVFile.Init(',');
	cCSVFile.Open(&cMemoryFile);
	cCSVFile.ReadAllLines();

	for (iRow = 0; iRow < cCSVFile.NumRows(); iRow++)
	{
		psRow = cCSVFile.Get(iRow);

		for (i = 0; i < psRow->iNumFields; i++)
		{
			szCelIndex = psRow->Get(i);
			cTextParser.Init(szCelIndex);
			tResult = cTextParser.GetInteger(&iCelIndex);
			if (tResult != TRITRUE)
			{
				szError.Init("CSV cell [");
				szError.Append(i);
				szError.Append(", ");
				szError.Append(iRow);
				szError.Append("] could not be parsed as an integer.");
				CMarkupTextParser::LogError(pcTag, szError.Text());
				szError.Kill();
				cCSVFile.Close();
				cMemoryFile.Kill();
				szCSV.Kill();
				return FALSE;
			}
			
			pcTile = pcLayer->mpcTileType->Get(iCelIndex);
			if (pcTile)
			{
				pcLayer->Set(i, iRow, pcTile);
			}
		}
	}

	cCSVFile.Close();
	cMemoryFile.Kill();
	szCSV.Kill();
	return TRUE;
}