createindex.cpp

手机编程

#include "CreateIndex.h"
#include "StructDefine.h"
#include "GridDemoAppUi.h"
#include <GridDemo.rsg>
#include <bautils.h>

CCreateIndex::CCreateIndex(RFs& aFs,  MCreateIndexObserver& aObserver)
 :	CActive(EPriorityStandard),	iFs(aFs), iObserver(aObserver)
{
	iOverwriteExistsFile = ETrue;
}

CCreateIndex::~CCreateIndex()
{
	Cancel();
	iFileList->Reset();
	delete iFileList;

	iSmokeFlowNoIndex.ResetAndDestroy();
	iSmokeFlowCodeIndex.ResetAndDestroy();
}

void CCreateIndex::ConstructL()
{
	iFileList = new (ELeave) CDesCArrayFlat(10);
	
	iIndexFormat.Copy(_L("%-13S%8d\r\n"));
	CreateFileList();
	CActiveScheduler::Add(this);
}

void CCreateIndex::CreateFileList()
{
	TInt i;
	iFileList->AppendL(KSmokeYearFile);
	iFileList->AppendL(KSmokeRealInfoFile);

	CDesCArray* fileArray = new (ELeave) CDesCArrayFlat(10);
	FindFileBy(_L("month"), fileArray);

	for(i=0; i<fileArray->Count(); i++)
		iFileList->AppendL((*fileArray)[i]);

	fileArray->Reset();

	FindFileBy(_L("flow"), fileArray);

	for(i=0; i<fileArray->Count(); i++)
		iFileList->AppendL((*fileArray)[i]);

	fileArray->Reset();
	delete fileArray;
}

void CCreateIndex::FindFileBy(const TDesC& aPrevString, CDesCArray* aFileArray)
{
	CDir* aFileList;
	aFileArray->Reset();

	if (iMyAppUi->FsSession().GetDir(KDefaultDataFolder,KEntryAttMaskSupported,EDirsFirst|ESortByName,aFileList)!=KErrNone)
		return;

	TBuf<32> myDatFile;
	myDatFile = aPrevString;
	myDatFile.Append(_L("*.dat"));

	for (TInt i=0;i<aFileList->Count();i++) 
	{
		TEntry anEntry = (*aFileList)[i];

		if (!anEntry.IsDir())
		{
			if(anEntry.iName.MatchF(myDatFile) == KErrNotFound)
				continue;
			
			aFileArray->AppendL(anEntry.iName);
		}
	}

	delete aFileList;
}

CCreateIndex* CCreateIndex::NewL(RFs& aFs,  MCreateIndexObserver& aObserver)
{
	CCreateIndex* self =  new (ELeave) CCreateIndex(aFs, aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
}

void CCreateIndex::DoCancel()
{
	CloseFile();
}

TInt CCreateIndex::ProgressCount()
{
	return iFileList->Count();
}

void CCreateIndex::Start(TInt aFileIndex)
{
	if(aFileIndex < iFileList->Count())
	{
		iCurrentFileIndex = aFileIndex;
		iSourceFileName = (*iFileList)[aFileIndex];

		if(iSourceFileName[0] == 's')
		{
			iType = ECreateIndexYear;
			iIndexSize = 17;
			iIndexFormat.Copy(_L("%-17S%8d\r\n"));
			iRecordSize = TSmokeYear::Size();
		}
		else if(iSourceFileName[0] == 'm')
		{
			iType = ECreateIndexMonth;
			iIndexSize = 13;
			iIndexFormat.Copy(_L("%-13S%8d\r\n"));
			iRecordSize = TSmokeMonth::Size();
		}
		else if(iSourceFileName[0] == 'f')
		{
			iType = ECreateIndexFlow;
			iIndexSize = 25;
			iRecordSize = TSmokeFlow::Size();
		}
		else if(iSourceFileName[0] == 'p')
		{
			iType = ECreateIndexRealInfo;
			iIndexSize = 13;
			iIndexFormat.Copy(_L("%-13S%8d\r\n"));
			iRecordSize = TSmokeRealInfo::Size();
		}
		else
			return;

		iMyAppUi->CompleteWithDataPath(iSourceFileName);
		
		if(!BaflUtils::FileExists(iFs, iSourceFileName))
		{
			iMyAppUi->ShowInformationNoteL(R_FILE_NO_FOUND);
			return;
		}

		iIndexFileName = iSourceFileName;
		iIndexFileName.Replace(iIndexFileName.Length() - 3, 3, _L("idx"));

		TInt file_err = iIndexFile.Replace(iFs, iIndexFileName, EFileWrite);
		if(file_err != KErrNone)
		{
			User::Leave(file_err);
			return ;
		}

		iIndexFileIsOpen = ETrue;

		User::LeaveIfError(iSourceFile.Open(iFs, iSourceFileName, EFileRead));
		iSourceFileIsOpen = ETrue;

		TInt size;
		iSourceFile.Size(size);

		iFilePos = 0;
		iRecordCount = size / iRecordSize;
		iCurrentRecordRow = 0;

		iBuffer.Zero();

		iObserver.HandleChangeFile();

		iSourceFile.Read(iFilePos, iBuffer, iIndexSize, iStatus);
		SetActive();
	}
}

void CCreateIndex::RunL()
{
	if(iStatus.Int() == KErrNone)
	{
		HandleNextBuffer();
	}
}

void CCreateIndex::HandleNextBuffer()
{
	if(iType == ECreateIndexFlow)
	{
		ParseFlowCode();
		ParseFlowNo();

		iCurrentRecordRow++;
		if(iCurrentRecordRow >= iRecordCount)
		{
			SaveFlowIndex();
			iSmokeFlowNoIndex.ResetAndDestroy();
			iSmokeFlowCodeIndex.ResetAndDestroy();
			HandleNextFile();
			return;
		}
	}
	else
	{
		if(iBuffer.Compare(iOldBuffer) != 0)
		{
			TBuf8<32> buf;
			buf.Format(iIndexFormat, &iBuffer, iCurrentRecordRow);
			iIndexFile.Write(buf);
			iOldBuffer = iBuffer;
		}

		iCurrentRecordRow++;
		if(iCurrentRecordRow >= iRecordCount)
		{
			iBuffer.Repeat(_L8("9"));
			iBuffer.SetLength(iIndexSize);
			TBuf8<32> buf;
			buf.Format(iIndexFormat, &iBuffer, iCurrentRecordRow);
			iIndexFile.Write(buf);

			HandleNextFile();
			return;
		}
	}

	iFilePos = iRecordSize * iCurrentRecordRow;
	iSourceFile.Read(iFilePos, iBuffer, iIndexSize, iStatus);
	SetActive();
}

void CCreateIndex::HandleNextFile()
{
	CloseFile();

	iCurrentFileIndex++;
	if(iCurrentFileIndex >= iFileList->Count())
	{
		iObserver.HandleCreateFinished();
		return;
	}

	Start(iCurrentFileIndex);
}

void CCreateIndex::ParseFlowNo()
{
	if(iBuffer.Length() < 25)
		return;

	TPtrC8  noBuf = iBuffer.Left(13);

	for(TInt i=0; i<iSmokeFlowNoIndex.Count(); i++)
	{
		if(iSmokeFlowNoIndex[i]->iNo.Compare(noBuf) == 0)
		{
			iSmokeFlowNoIndex[i]->iLineArray.Append(iCurrentRecordRow);
			return;
		}
	}
	TSmokeFlowNoIndex* fni = new (ELeave) TSmokeFlowNoIndex;
	fni->iNo = noBuf;
	fni->iLineArray.Reset();
	fni->iLineArray.Append(iCurrentRecordRow);
	iSmokeFlowNoIndex.Append(fni);
}

void CCreateIndex::ParseFlowCode()
{
	if(iBuffer.Length() < 25)
		return;

	TPtrC8 codeBuf = iBuffer.Right(10);

	for(TInt i=0; i<iSmokeFlowCodeIndex.Count(); i++)
	{
		if(iSmokeFlowCodeIndex[i]->iCode.Compare(codeBuf) == 0)
		{
			iSmokeFlowCodeIndex[i]->iLineArray.Append(iCurrentRecordRow);
			return;
		}
	}
	TSmokeFlowCodeIndex* fci = new (ELeave) TSmokeFlowCodeIndex;
	fci->iCode = codeBuf;
	fci->iLineArray.Reset();
	fci->iLineArray.Append(iCurrentRecordRow);
	iSmokeFlowCodeIndex.Append(fci);
}

void CCreateIndex::SaveFlowIndex()
{
	TBuf<256> fname;
	TInt i,j;

	fname = iSourceFileName;
	fname.Replace(fname.Length() - 4, 4, _L("_no.idx"));
	RFile file;
	file.Replace(iFs, fname, EFileWrite);

	TBuf8<2048> lbuf;
	for(i=0; i<iSmokeFlowNoIndex.Count(); i++)
	{
		lbuf.Copy(iSmokeFlowNoIndex[i]->iNo);
		lbuf.Append(' ');

		TBuf8<32> buf;
		for(j=0; j<iSmokeFlowNoIndex[i]->iLineArray.Count(); j++)
			lbuf.AppendFormat(_L8("%d,"), iSmokeFlowNoIndex[i]->iLineArray[j]);

		lbuf.Append('\n');
		file.Write(lbuf);
	}

	file.Close();

	fname = iSourceFileName;
	fname.Replace(fname.Length() - 4, 4, _L("_code.idx"));
	file.Replace(iFs, fname, EFileWrite);
	for(i=0; i<iSmokeFlowCodeIndex.Count(); i++)
	{
		lbuf.Copy(iSmokeFlowCodeIndex[i]->iCode);
		lbuf.Append(' ');


		for(j=0; j<iSmokeFlowCodeIndex[i]->iLineArray.Count(); j++)
			lbuf.AppendFormat(_L8("%d,"), iSmokeFlowCodeIndex[i]->iLineArray[j]);

		lbuf.Append('\n');
		file.Write(lbuf);
	}
	file.Close();
}

TInt CCreateIndex::RunError(TInt /*aError*/)
{
	return KErrNone;
}

void CCreateIndex::CloseFile()
{
	if(iIndexFileIsOpen)
	{
		iIndexFile.Close();
		iIndexFileIsOpen = EFalse;
	}

	if(iSourceFileIsOpen)
	{
		iSourceFile.Close();
		iSourceFileIsOpen = EFalse;
	}
}