File, Streams and Stores

   /* Txt file to be opened. */
   RFile file ;
   file.Open(aFs, aFilename,EFileRead) ;
   CleanupClosePushL(file);

   /* Size of file. */
   TInt iSize ;   
   file.Size(iSize) ;
   
   /* Allocate enough memory to read in the whole file. */
   HBufC8* buf = HBufC8::NewL(iSize) ;

   /* Get a pointer to modify contents of buffer. */
   TPtr8  pBuf = buf->Des() ;

   /* Read data into buf. */
   file.Read(pBuf) ;

   CleanupStack::PopAndDestroy() ; // file

//
// Open a RFs
RFs aFs;
User::LeaveIfError(aFs.Connect());
CleanupClosePushL(aFs);

_LIT(KStreamName, "C:\\TestStream.dat");

//
// Delete old file
aFs.Delete(KStreamName);

//
// Open a file write stream
RFileWriteStream fWrite;
User::LeaveIfError(fWrite.Create(aFs, KStreamName, EFileWrite));
CleanupClosePushL(fWrite);

//
// Write to the stream and commit it
_LIT(KTextToCopy, "This is a test stream");
fWrite << KTextToCopy(); // Warning, this _CAN_ leave
fWrite.CommitL();

//
// Close the stream
CleanupStack::PopAndDestroy(&fWrite);

//
// Open a read stream
RFileReadStream fRead;
User::LeaveIfError(fRead.Open(aFs, KStreamName, EFileRead));
CleanupClosePushL(fRead);

//
// Read data back from the stream.  Using the HBufC::NewL which takes a RReadStream
// so we get a buffer exactly the right size for whats in the stream
HBufC* pBuf = HBufC::NewL(fRead, 1000);

//
// Close the read stream
CleanupStack::PopAndDestroy(&fRead);

//
// Close the RFs
CleanupStack::PopAndDestroy(&aFs);

//
// A class for correct cleanup of RPointerArrays
template <class T>
class CleanupResetAndDestroyClose
{
public:
inline static void PushL(T& aRef)
{CleanupStack::PushL(TCleanupItem(&Close,&aRef));}

static void Close(TAny *aPtr)
{
(STATIC_CAST(T*,aPtr))->ResetAndDestroy();
(STATIC_CAST(T*,aPtr))->Close();
}
};

template <class T>
inline void CleanupResetAndDestroyClosePushL(T& aRef)
{CleanupResetAndDestroyClose<T>::PushL(aRef);}

//
// A class we wish to put into the store
class CFoo : public CBase
{
public:
CFoo() {}
TBuf<20> iName;
TInt iSomeData;

TStreamId StoreL(CStreamStore& aStore) const;
void ExternalizeL(RWriteStream& aStream) const;
void RestoreL(CStreamStore& aStore,TStreamId anId);
void InternalizeL(RReadStream& aStream);
};

//
// Create a stream, and externilize ourselfs into it
TStreamId CFoo::StoreL(CStreamStore& aStore) const
{
RStoreWriteStream outstream;
TStreamId id = outstream.CreateLC(aStore);
ExternalizeL(outstream);
outstream.CommitL();
CleanupStack::PopAndDestroy(&outstream);
return id;
}

void CFoo::ExternalizeL(RWriteStream& aStream) const
{
aStream << iName;
aStream.WriteInt16L(iSomeData);
}

//
// Open up the given stream, and restore from it
void CFoo::RestoreL(CStreamStore& aStore,TStreamId anId)
{
RStoreReadStream stream;
stream.OpenLC(aStore,anId);
InternalizeL(stream);
CleanupStack::PopAndDestroy(&stream);
}

void CFoo::InternalizeL(RReadStream& aStream)
{
aStream >> iName;
iSomeData = aStream.ReadInt16L();
}

//
// Add each record to the store
void DoSaveToStoreL(CFileStore* aStore)
{
RPointerArray<CFoo> rObs;
CleanupResetAndDestroyClosePushL(rObs);

CFoo* pFoo1 = new CFoo;
CleanupStack::PushL(pFoo1);
pFoo1->iName.Copy(_L("Test Ob1"));
pFoo1->iSomeData = 1;
User::LeaveIfError(rObs.Append(pFoo1));
CleanupStack::Pop(pFoo1);

CFoo* pFoo2 = new CFoo;
CleanupStack::PushL(pFoo2);
pFoo2->iName.Copy(_L("Test Ob2"));
pFoo2->iSomeData = 2;
User::LeaveIfError(rObs.Append(pFoo2));
CleanupStack::Pop(pFoo2);

RArray < TStreamId > rIndexArray;
CleanupClosePushL(rIndexArray);

//
// Store each object from rObs into the store.  Each object will create it's own stream
// in the store, and it's id will be returned from ->StoreL.  We then store the ids in a
// index which we store in the root stream of the store.
for(TInt n = 0; n < rObs.Count(); ++n)
{
TStreamId id = rObs[n]->StoreL(*aStore);
User::LeaveIfError(rIndexArray.Append(id));
}

//
// Write index
RStoreWriteStream rs;
rs.ReplaceLC(*aStore, aStore->Root());

rs.WriteInt16L(rIndexArray.Count());

for(TInt nn = 0; nn < rIndexArray.Count(); ++nn)
{
//
// Write name
rs << rObs[nn]->iName;

//
// And index
rs << rIndexArray[nn];
}

rs.CommitL();
CleanupStack::PopAndDestroy(&rs);

//
// Commit the store
aStore->CommitL();

//
// Done with the index array
CleanupStack::PopAndDestroy(&rIndexArray);

//
// And the objects
CleanupStack::PopAndDestroy(&rObs);
}

LOCAL_C void doExampleL()
{
//
// Open a RFs
RFs aFs;
User::LeaveIfError(aFs.Connect());
CleanupClosePushL(aFs);

_LIT(KStoreName, "C:\\TestStore.dat");

//
// Create a perminate file store
CPermanentFileStore* pStore = CPermanentFileStore::ReplaceLC(aFs, KStoreName, EFileWrite);
pStore->SetTypeL(KPermanentFileStoreLayoutUid);

//
// Write a fake root stream containg 0 for the entry count
RStoreWriteStream rs;
TStreamId id = rs.CreateLC(*pStore);
rs.WriteInt16L(0);
rs.CommitL();
pStore->SetRootL(id);
pStore->CommitL();
CleanupStack::PopAndDestroy(&rs);

//
// Generate some objects and save them to the store
TRAPD(err, DoSaveToStoreL(pStore));
if(err != KErrNone)
{
pStore->Revert();
User::Leave(err);
}

//
// The store now contains a series of streams, and each stream contains it's own CFoo, which
// we can load independatly of each other

//
// Close the store
CleanupStack::PopAndDestroy(pStore);

//
// Open up the store for reading
CPermanentFileStore* pReadStore = CPermanentFileStore::OpenLC(aFs,
KStoreName, EFileRead);

//
// Go through the ids, and look for the one called Test Ob2 to demonstrate
// we don't need to load Test Ob1 to get at Test Ob2 as we would if we were
// using a normal stream
TInt nRecordCount = 0;

RStoreReadStream streamIn;
streamIn.OpenLC(*pReadStore, pReadStore->Root());
nRecordCount = streamIn.ReadInt16L();

TStreamId nTheId;

for(TInt n = 0; n < nRecordCount; ++n)
{
//
// Read name
TBuf<20> iName;
streamIn >> iName;

TStreamId id;
streamIn >> id;
if(iName.Compare(_L("Test Ob2")) == 0)
{
//
// Found it!
nTheId = id;
break;
}
}

CleanupStack::PopAndDestroy(&streamIn);

if(nTheId != KNullStreamId)
{
//
// Load er back in
CFoo* pOb2 = new CFoo;
CleanupStack::PushL(pOb2);

//
// Restore it
pOb2->RestoreL(*pReadStore, nTheId);

//
// Do something with it
// .
// ,
//
// Destory it
CleanupStack::PopAndDestroy(pOb2);
}

//
// Close the store
CleanupStack::PopAndDestroy(pReadStore);


//
// Close the RFs
CleanupStack::PopAndDestroy(&aFs);
}