examples/SysLibs/FileStores/WritePermFS1/WritePermFS1.cpp

/*
Copyright (c) 2000-2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of Nokia Corporation nor the names of its contributors
  may be used to endorse or promote products derived from this software
  without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Description: 
Example constructs and writes a network of objects to a permanent file store.
Each object is then loaded back in, one at a time, its content displayed at the 
console and then destroyed.
The CClassR object is changed and stored back before it is destroyed 
The order in which the objects are loaded from the store is different from the order
in which they were initially created.
The example creates an index of "top level" stream ids. The index is stored in its
own stream and forms the root stream of the store. 
The example:
creates a permanent file store (replacing any existing permanent 
file store of the same name)
constructs a TExampleIndex object
constructs a CClassP object, externalizes it in its own stream, 
saves the stream id in the index and then destroys the 
CClassP object
constructs a CClassR object, externalizes it in its own stream, 
saves the stream id in the index and then destroys the 
CClassR object
constructs a CClassABC container object containing a CClassA, 
a CClassB and a CClassC object and then completes the construction
of these contained objects.
The CClassB object is externalized in its own stream. The CClassA, the streamid of the
CClassB object and the CClassC object are externalized in a single
stream and this streamid is saved into the index
externalizes the TExampleIndex object in its own stream and makes
this stream the root stream of the file store.
closes the permanent file store.
re-opens the permanent file store
restores the TExampleIndex object from the root stream
restores the CClassR object from its stream, displays the content,
changes the content, replaces the stream and then destroys the object from
memory
restores the CClassR object for a second time from its stream, displays 
the (updated) content and then destroys the object from memory again
restores the CClassABC container object; in effect, this restores 
its contained CClassA and CClassC objects and the stream id of its
CClassB object. The CClassB object is not restored into memory until 
it is needed. 
displays the content of the CClassA, CClassB and CClassC objects; it is
at this time that the CClassB object is restored into memory.
restores the CClassP object from its stream and displays its contents
and then destroys it
(NB that the order in which the objects are restored is different to 
the order in which their corresponding streams were created)
closes the permanent file store.
Notes:
The file name and extension of the permanent file store is 
"WritePermFS.dat"and will be created in "\epoc32ex\data\" on the system drive. 
*/



#include "WritePermFS1.h"

//***************************************************************
//
// Implementations
//
//***************************************************************


// The file name, extension and path for the file store
_LIT(KFullNameOfFileStore,"\\epoc32ex\\data\\WritePermFS.dat");

                                //  Do the example
LOCAL_C void doExampleL()
    {
                                // make sure directory exists
        fsSession.MkDirAll(KFullNameOfFileStore);
        doMakeL(KFullNameOfFileStore);
        doUseL(KFullNameOfFileStore);
        }
 

LOCAL_C void doMakeL(const TDesC& aName)
        {
                                // Create (replace, if it exists) the permanent file store
        TParse  filestorename;
        fsSession.Parse(aName,filestorename);
        CFileStore* store = CPermanentFileStore::ReplaceLC(fsSession,filestorename.FullName(),EFileWrite);

                                // Must say what kind of file store.
        store->SetTypeL(KPermanentFileStoreLayoutUid);

                                // Create a TExampleIndex object to hold the stream ids of all
                                // the component streams
        TExampleIndex theIndex;

                                // Construct the CClassP object, putting some data into it, 
                                // write it to its own stream and save the stream id in
                                // the index.
                                // Destroy the CClassP object after stream creation
        _LIT(KTxtDataForClassP,"Data for CClassP - PPPPP");
        CClassP* theP = CClassP::NewLC(KTxtDataForClassP,*store);
        theIndex.iPid = theP->StoreL();
        CleanupStack::PopAndDestroy();
        
                                // Construct the CClassR object, put some data into it, 
                                // write it to its own stream and save the stream id in
                                // the index.
                                // Destroy the CClassR object after stream creation
        _LIT(KTxtDataForClassR,"Data for the CClassR - RRRRR");
        CClassR* theR = CClassR::NewLC(KTxtDataForClassR,*store);
        theIndex.iRid = theR->StoreL();
        CleanupStack::PopAndDestroy();                                                  
                                
                                // Construct the container object for CClassA,CClassB and CClassC.
                                // Complete the construction of the contained CClassA, CClassB
                                // and CClassC objects.
                                //  
                                // Write out this object network and save the top level stream id
                                // in the index.
                                // Destroy this object network after stream creation
        _LIT(KTxtDataForClassA,"Data for the CClassA - AAAAA");
        _LIT(KTxtDataForClassB,"Data for the CClassB - BBBBB");
        _LIT(KTxtDataForClassC,"Data for the CClassC - CCCCC");

        CClassABC* theABC = CClassABC::NewLC(*store);
        theABC->ConstructAL(KTxtDataForClassA,-1,2);
        theABC->ConstructB(KTxtDataForClassB,-3,4,5.6);
        theABC->ConstructC(KTxtDataForClassC);
        theIndex.iABCid = theABC->StoreL();
        CleanupStack::PopAndDestroy();                                                  

                                // Now write the index itself to its own stream ...
        TStreamId id  = theIndex.StoreL(*store);

                                // ... and make this stream the root stream
        store->SetRootL(id);

                                // Now commit all changes to the store
        store->CommitL();
                        
                                // Destroy the permanent file store object (closes the file)
        CleanupStack::PopAndDestroy();  
        }


LOCAL_C void doUseL(const TDesC& aName)
        {
                                // Open the permanent file store
        TParse  filestorename;
        fsSession.Parse(aName,filestorename);
        CFileStore* store = CPermanentFileStore::OpenLC(fsSession,filestorename.FullName(),EFileRead|EFileWrite);

                                // Restore the index of streamids so that we can access (restore)
                                // all the other objects. The index is found in the root stream 
        TExampleIndex theIndex;
        theIndex.RestoreL(*store,store->Root());
                                
                                // Restore the CClassR object, display the content, make a change and
                                // update the stream to reflect the changed content.
                                // If updating the stream succeeds, commit the changes to the store
                                // otherwise attempt to revert the store to its state at the last
                                // commit point.
                                // Destroy the CClassR object.
        CClassR* theR;

        _LIT(KTxtClassRContent,"CClassR content ...");
        _LIT(KTxtNewForClassR,"New data for the CClassR +++++++");

        theR = CClassR::NewLC(*store,theIndex.iRid);
        doShow(KTxtClassRContent,*theR);
        theR->ChangeDataL(KTxtNewForClassR);
        CleanupStack::PopAndDestroy();
                                
                                // Restore the CClassR object again, display the content and
                                // then destroy it
        _LIT(KTxtUpadtedClassR,"Updated CClassR content ...");

        theR = CClassR::NewLC(*store,theIndex.iRid);
        doShow(KTxtUpadtedClassR,*theR);
        CleanupStack::PopAndDestroy();

                                // Restore the CClassABC and display content of all contained objects.
                                // Note that the loading of the CClassB object is deferred until it 
                                // is needed.
                                // Destroy the CClassABC 
        _LIT(KTxtShowClassA,"CClassA content ...");
        _LIT(KTxtShowClassB,"CClassB content ...");
        _LIT(KTxtShowClassC,"CClassC content ...");

        CClassABC* theABC = CClassABC::NewLC(*store,theIndex.iABCid);
        doShow(KTxtShowClassA,*theABC->PtrA());
        doShow(KTxtShowClassB,*theABC->PtrBL());// CClassB object is loaded at this point
        doShow(KTxtShowClassC,*theABC->PtrC()); 
        CleanupStack::PopAndDestroy();

                                // Restore the CClassP object, display the content and
                                // then destroy it;
        _LIT(KTxtShowClassP,"CClassP content ...");

        CClassP* theP = CClassP::NewLC(*store,theIndex.iPid);
        doShow(KTxtShowClassP,*theP);
        CleanupStack::PopAndDestroy();

                                // Destroy the permanent file store object (closes the file) 
        CleanupStack::PopAndDestroy();
        } 

_LIT(KTxtNewLine,"\n");
_LIT(KFormatType1,"\n%S, ");
_LIT(KFormatType2,"%d, ");
_LIT(KFormatType3,"%u  ");
_LIT(KFormatType4,"%u, ");
_LIT(KFormatType5,"%f  ");
                                                                        
LOCAL_C void doShow(const TDesC& aHeading,const CClassA& anA)
        {
        console->Printf(KTxtNewLine);
        console->Printf(aHeading);
        console->Printf(KFormatType1,anA.iVarBuf);
        console->Printf(KFormatType2,anA.iIntValue);
        console->Printf(KFormatType3,anA.iUintValue);
        console->Printf(KTxtNewLine);
        }


LOCAL_C void doShow(const TDesC& aHeading,const CClassB& aB)
        {
        console->Printf(KTxtNewLine);
        console->Printf(aHeading);
        console->Printf(KFormatType1,&aB.iFixBuf);
        console->Printf(KFormatType2,aB.iIntValue);
        console->Printf(KFormatType4,aB.iUintValue);
        console->Printf(KFormatType5,aB.iRealValue);
        console->Printf(KTxtNewLine);
        }


LOCAL_C void doShow(const TDesC& aHeading,const CClassC& aC)
        {
        console->Printf(KTxtNewLine);
        console->Printf(aHeading);
        console->Printf(KFormatType1,&aC.iFixBuf);
        console->Printf(KTxtNewLine);
        }

LOCAL_C void doShow(const TDesC& aHeading,const CClassP& aP)
        {
        console->Printf(KTxtNewLine);
        console->Printf(aHeading);
        console->Printf(KFormatType1,&aP.iFixBuf);
        console->Printf(KTxtNewLine);
        }

LOCAL_C void doShow(const TDesC& aHeading,const CClassR& aR)
        {
        console->Printf(KTxtNewLine);
        console->Printf(aHeading);
        console->Printf(KFormatType1,&aR.iFixBuf);
        console->Printf(KTxtNewLine);
        }

//***************************************************************
//
// CClassABC Implementation
//
//***************************************************************
CClassABC::CClassABC(CStreamStore& aStore)
        : iStore(aStore)
        {}

CClassABC::CClassABC(CStreamStore& aStore,TStreamId anId)
        : iStore(aStore), iId(anId)
        {}

CClassABC* CClassABC::NewLC(CStreamStore& aStore)
        {
        CClassABC* self = new (ELeave) CClassABC(aStore);
        CleanupStack::PushL(self);
        self->ConstructL();
        return self;
        }

CClassABC* CClassABC::NewLC(CStreamStore& aStore, TStreamId anId)
        {                                                                                                                       
        CClassABC* self = new (ELeave) CClassABC(aStore,anId);
        CleanupStack::PushL(self);
        self->RestoreL();
        return self;
        }
                
void CClassABC::ConstructL()
        {
        iA = CClassA::NewL();
        iB = CClassB::NewL();// assigns CClassB* to TSwizzle<CClassB>. Uses TSwizzle operator=(T*)
        iC = CClassC::NewL();
        }

void CClassABC::ConstructAL(const TDesC& aData,TInt anInt,TUint aUint)
        {
        iA->iVarBuf    = aData.AllocL();        
        iA->iIntValue  = anInt;
        iA->iUintValue = aUint;
        }
                        
void CClassABC::ConstructB(const TDesC& aData,TInt anInt,TUint aUint,TReal aReal)
        {
        iB->iFixBuf    = aData;
        iB->iIntValue  = anInt; 
        iB->iUintValue = aUint;
        iB->iRealValue = aReal;
        }
                        
void CClassABC::ConstructC(const TDesC& aData)
        {
        iC->iFixBuf = aData;
        }

                        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
                        // Destructor deletes the CClassB object only if it is in memory.
                        // The IsPtr() function can be used to determine whether the 
                        // CClassB object is memory. 
                        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
CClassABC::~CClassABC()
        {
        delete iA;
        delete iC;
        if (iB.IsPtr())
                delete iB.AsPtr(); // can also "delete iB;" makes implicit call to "operator T*()"
        }

        
                                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
                                // Stores the CClassB object in its own stream and
                                // then stores:
                                //              the CClassA object,
                                //              the streamid of the CClassB object,
                                //              the CClassC object
                                // in a separate stream.
                                // Returns the streamid of this last stream
                                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
TStreamId CClassABC::StoreL()
        {
                                // Construct the output stream which is intended
                                // to hold the CClassB object only.
        RStoreWriteStream outstream;
        TStreamId idForB = outstream.CreateLC(iStore);
                                // Stream out the CClassB object.
                                // Note that the right hand side returns a reference
                                // to CClassB
        outstream  << *iB; 
                                // Commit changes to the stream
        outstream.CommitL();
                                // Cleanup the stream object
        CleanupStack::PopAndDestroy();  
                                // Now construct the output stream which is intended
                                // to hold:
                                //              the CClassA object,
                                //              the streamid of the CClassB object,
                                //              the CClassC object
        TStreamId id = outstream.CreateLC(iStore);
                                // Write out the CClassA object.
        outstream  << *iA; 
                                // Write out the stream id of the CClassB object
        outstream  << idForB;
                                // Write out the CClassC object.
        outstream  << *iC;
                                // Commit changes to the stream
        outstream.CommitL();
                                // Cleanup the stream object,
        CleanupStack::PopAndDestroy();  
                                // Return this stream id
        return id;
        }

                                
const CClassA* CClassABC::PtrA()
        {
        return iA;      // Return a pointer to the contained CClassA object
        }

                                
const CClassB* CClassABC::PtrBL()
        {
        if (iB.IsId())          // If the contained CClassB object is not in memory, it must
                RestoreBL();    // be loaded in before a pointer can be returned to the caller
        return iB.AsPtr();
        }

                                
const CClassC* CClassABC::PtrC()
        {
        return iC;      //Returns a pointer to the contained CClassC object
        }
                                
                                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
                                // Restores the CClassA and CClassC objects and the streamid for the
                                // CClassB object.
                                // The swizzle for the CClassB object is constructed from the
                                // streamid but the CClassB object itself is NOT restored at 
                                // this time.
                                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
void CClassABC::RestoreL()
        {
                                // Construct the input stream.
        RStoreReadStream instream;
        instream.OpenLC(iStore,iId);
                                // Construct a CClassA object and restore from the stream
        iA = CClassA::NewL();
        instream >> *iA;
                                // Construct the swizzle for the CClassB object. This
                                // stream contains the id of the stream which 
                                // actually contains the full CClassB object. The loading of
                                // the CClassB object into memory is deferred until later.
                                // The resulting swizzle represents the CClassB object as 
                                // a streamid 
        instream >> iB;
                                // Construct a CClassC object and restrore from the stream
        iC = CClassC::NewL();
        instream >> *iC;
                                // Cleanup the stream object
        CleanupStack::PopAndDestroy();
        }


                                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
                                // Loads the CClassB object into memory and changes the swizzle's
                                // representation from "streamid" to "pointer".
                                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
void CClassABC::RestoreBL()
        {
                                // Construct the input stream. Assumes we have the correct store (this
                                // emphasizes the need to ensure that the store remain open)
        RStoreReadStream instream;
        instream.OpenLC(iStore,iB.AsId());
                                // Construct a CClassB object and restore from the stream. The 
                                // assignment: CClassB* to TSwizzle<CClassB> changes the
                                // swizzle's representation of the CClassB object 
                                // from "streamid" to "pointer"
        CClassB* ptrB = CClassB::NewLC();
        instream >> *ptrB;
        CleanupStack::Pop();
        iB = ptrB;
                                // Cleanup the stream object                    
        CleanupStack::PopAndDestroy();
        }       


//***************************************************************
//
// CClassA Implementation
//
//***************************************************************
CClassA* CClassA::NewL()
        {
        CClassA* self = CClassA::NewLC();
        CleanupStack::Pop();
        return self;
        }

CClassA* CClassA::NewLC()
        {
        CClassA* self = new (ELeave) CClassA;
        CleanupStack::PushL(self);
        return self;
        }

CClassA::~CClassA()
        {
        delete iVarBuf;
        }

void CClassA::ExternalizeL(RWriteStream& aStream) const
        {
        aStream.WriteInt32L(iVarBuf->Des().MaxLength());
        aStream << *iVarBuf;
        aStream.WriteInt32L(iIntValue);
        aStream.WriteUint32L(iUintValue);
        }  
 
void CClassA::InternalizeL(RReadStream& aStream)
        {
        TInt maxlen;
        maxlen     = aStream.ReadInt32L();
        iVarBuf    = HBufC::NewL(aStream,maxlen);
        iIntValue  = aStream.ReadInt32L();
        iUintValue = aStream.ReadUint32L();
        }  
                

//***************************************************************
//
// CClassB Implementation
//
//***************************************************************
CClassB* CClassB::NewLC()
        {
        CClassB* self = new (ELeave) CClassB;
        CleanupStack::PushL(self);
        return self;
        }

CClassB* CClassB::NewL()        
        {
        CClassB* self = CClassB::NewLC();
        CleanupStack::Pop();    
        return self;
        }

void CClassB::ExternalizeL(RWriteStream& aStream) const
        {
        aStream << iFixBuf;
        aStream.WriteInt32L(iIntValue);
        aStream.WriteUint32L(iUintValue);
        aStream.WriteReal64L(iRealValue);
        }  
 
void CClassB::InternalizeL(RReadStream& aStream)
        {
        aStream >> iFixBuf;
        iIntValue  = aStream.ReadInt32L();
        iUintValue = aStream.ReadUint32L();
        iRealValue = aStream.ReadReal64L();
        }  

//***************************************************************
//
// CClassC Implementation
//
//***************************************************************
CClassC* CClassC::NewL()
        {
        CClassC* self = CClassC::NewLC();
        CleanupStack::Pop();
        return self;
        }

CClassC* CClassC::NewLC()
        {
        CClassC* self = new (ELeave) CClassC;
        CleanupStack::PushL(self);
        return self;
        }

void CClassC::ExternalizeL(RWriteStream& aStream) const
        {
        aStream << iFixBuf;
        }  
 
void CClassC::InternalizeL(RReadStream& aStream)
        {
        aStream >> iFixBuf;
        }  

//***************************************************************
//
// CClassP Implementation
//
//***************************************************************
CClassP::CClassP(CStreamStore& aStore)
        : iStore(aStore)
        {}

CClassP::CClassP(CStreamStore& aStore,TStreamId anId)
        : iStore(aStore), iId(anId)
        {}

CClassP* CClassP::NewLC(const TDesC& aData,CStreamStore& aStore)
        {
        CClassP* self = new (ELeave) CClassP(aStore);
        CleanupStack::PushL(self);
        self->Construct(aData);
        return self;
        }

CClassP* CClassP::NewLC(CStreamStore& aStore, TStreamId anId)
        {
        CClassP* self = new (ELeave) CClassP(aStore,anId);
        CleanupStack::PushL(self);
        self->RestoreL();
        return self;
        }

void CClassP::Construct(const TDesC& aData)
        {
        iFixBuf = aData;
        }

void CClassP::RestoreL()
        {
        RStoreReadStream instream;
        instream.OpenLC(iStore,iId);
        InternalizeL(instream);                 // or we can say instream >> *this;
        CleanupStack::PopAndDestroy();  
        }

TStreamId CClassP::StoreL()
        {
        RStoreWriteStream outstream;
        TStreamId id = outstream.CreateLC(iStore);
        ExternalizeL(outstream);                // or we can say outstream << *this;
        outstream.CommitL();
        CleanupStack::PopAndDestroy();  
        return id;
        }

void CClassP::ExternalizeL(RWriteStream& aStream) const
        {
        aStream << iFixBuf;
        }  
 
void CClassP::InternalizeL(RReadStream& aStream)
        {
        aStream >> iFixBuf;
        }  


//***************************************************************
//
// CClassR Implementation
//
//***************************************************************
CClassR::CClassR(CStreamStore& aStore)
        : iStore(aStore)
        {}

CClassR::CClassR(CStreamStore& aStore,TStreamId anId)
        : iStore(aStore), iId(anId)
        {}

CClassR* CClassR::NewLC(const TDesC& aData,CStreamStore& aStore)
        {
        CClassR* self = new (ELeave) CClassR(aStore);
        CleanupStack::PushL(self);
        self->Construct(aData);
        return self;
        }

CClassR* CClassR::NewLC(CStreamStore& aStore, TStreamId anId)
        {
        CClassR* self = new (ELeave) CClassR(aStore,anId);
        CleanupStack::PushL(self);
        self->RestoreL();
        return self;
        }

void CClassR::Construct(const TDesC& aData)
        {
        iFixBuf = aData;
        }

_LIT(KTxtFailedMsg,"Failed to update CClassR stream\n");

void CClassR::ChangeDataL(const TDesC& aData)
        {
        iFixBuf = aData;
        TRAPD(error,UpdateStoreL());
        if (error!=KErrNone)
                {
                iStore.Revert();
                console->Printf(KTxtFailedMsg);
                User::Leave(error);
                }
        }
                
void CClassR::RestoreL()
        {
        RStoreReadStream instream;
        instream.OpenLC(iStore,iId);
        InternalizeL(instream);                 // or we can say instream >> *this;
        CleanupStack::PopAndDestroy();  
        }

TStreamId CClassR::StoreL()
        {
        RStoreWriteStream outstream;
        TStreamId id = outstream.CreateLC(iStore);
        ExternalizeL(outstream);                // or we can say outstream << *this;
        outstream.CommitL();
        CleanupStack::PopAndDestroy();  
        return id;
        }

void CClassR::UpdateStoreL()
        {
        RStoreWriteStream outstream;
        outstream.ReplaceLC(iStore,iId);
        ExternalizeL(outstream);                // or we can say outstream << *this;
        outstream.CommitL();
        CleanupStack::PopAndDestroy();
        iStore.CommitL();// commit the changes to the store
        }

void CClassR::ExternalizeL(RWriteStream& aStream) const
        {
        aStream << iFixBuf;
        }  
 
void CClassR::InternalizeL(RReadStream& aStream)
        {
        aStream >> iFixBuf;
        }  

//***************************************************************
//
// TExampleIndex Implementation
//
//***************************************************************

TStreamId TExampleIndex::StoreL(CStreamStore& aStore)
        {
        RStoreWriteStream outstream;
        TStreamId id = outstream.CreateLC(aStore);
        ExternalizeL(outstream);                // or we can say outstream << *this;
        outstream.CommitL();
        CleanupStack::PopAndDestroy();  
        return id;
        }

void TExampleIndex::RestoreL(CStreamStore& aStore, TStreamId anId)
        {
        RStoreReadStream instream;
        instream.OpenLC(aStore,anId);
        InternalizeL(instream);
        CleanupStack::PopAndDestroy();  
        }

void TExampleIndex::ExternalizeL(RWriteStream& aStream) const
        {
        aStream << iPid;
        aStream << iRid;
        aStream << iABCid;
        }  

void TExampleIndex::InternalizeL(RReadStream& aStream)
        {
        aStream >> iPid;
        aStream >> iRid;
        aStream >> iABCid;
        }  

---