StreamInStore
: stream creation in a non-persistent
store
These are the main files contained in the examples. Some extra files may be needed to run the examples, and these will be found in the appropriate examples directory.
Found in: examples\Syslibs\Stores\StreamInStore
// StreamInStore.cpp
//
// Copyright (c) 2000 Symbian Ltd. All rights reserved.
// Example to demonstrate stream creation in a non persistent store.
//
// The example:
// constructs two different types of object,
//
// writes them to a single stream contained in
// the in-memory store (a CBufStore),
//
// displays the contents of the objects,
//
// deletes them from memory,
//
// restores them from the store,
//
// displays the contents of the restored objects
#include "CommonStreamStore.h"
#include <s32file.h>
#include <s32mem.h>
//
// Format types and the newline character
//
_LIT(KTxtNewLine,"\n");
_LIT(KFormatType1,"\n%S, ");
_LIT(KFormatType2,"%d, ");
_LIT(KFormatType3,"%u, ");
_LIT(KFormatType4,"%u ");
_LIT(KFormatType5,"%f ");
// Constructs an object of type CClassA and an object
// of type CClassB, externalizes them to a
// non-persistent store and then destroys the
// CClassA object.
LOCAL_C void doMakeAndStoreL(CStreamStore& aStore,TStreamId& anId);
// Constructs "empty" CClassA and CClassB objects and
// restores them from the in-memory store.
LOCAL_C void doRestoreL(CStreamStore& aStore,const TStreamId& anId);
// Displays the contents of a CClassA object
class CClassA;
LOCAL_C void doShow(const TDesC& aHeading,const CClassA& anA);
// Displays the contents of a CClassB object
class CClassB;
LOCAL_C void doShow(const TDesC& aHeading,const CClassB& aB);
// definition of CClassA
class CClassA : public CBase
{
public :
static CClassA* NewLC();
~CClassA();
void SetTextL(const TDesC& aData);
void ExternalizeL(RWriteStream& aStream) const;
void InternalizeL(RReadStream& aStream);
public :
HBufC* iVarBuffer;
TInt iIntValue;
TUint iUintValue;
};
// definition of CClassB
class CClassB : public CBase
{
public :
static CClassB* NewLC();
void ExternalizeL(RWriteStream& aStream) const;
void InternalizeL(RReadStream& aStream);
public :
TBuf<32> iFixBuffer;
TUint iUintValue;
TInt iIntValue;
TReal iRealValue;
};
// Do the example
LOCAL_C void doExampleL()
{
// The stream id, kept in memory and used
// to access the (one and only stream) in the
// non-persistent store
TStreamId theId;
// construct a CBufStore, an in-memory
// non-persistent store.
CStreamStore* store = CBufStore::NewLC(2 /*granularity*/);
doMakeAndStoreL(*store,theId);
doRestoreL(*store,theId);
// destroy the CBufStore object
CleanupStack::PopAndDestroy();
}
LOCAL_C void doMakeAndStoreL(CStreamStore& aStore,TStreamId& anId)
{
// Construct an object of type CClassA and put some
// data into it
_LIT(KTxtForClassA,"Text for CClassA");
CClassA* theA = CClassA::NewLC();
theA->SetTextL(KTxtForClassA);
theA->iIntValue = -1;
theA->iUintValue = 2;
// Construct an object of type CClassB and put some
// data into it
_LIT(KTxtForClassB,"Text for CClassB");
CClassB* theB = CClassB::NewLC();
theB->iFixBuffer = KTxtForClassB;
theB->iIntValue = -3;
theB->iUintValue = 4;
theB->iRealValue = 5.6;
// Show contents of the CClassA object
_LIT(KTxtClassAContent,"CClassA content ...");
doShow(KTxtClassAContent,*theA);
// Show contents of the CClassB object
_LIT(KTxtClassBContent,"CClassB content ...");
doShow(KTxtClassBContent,*theB);
// Construct the output stream.
// The stream id (there is only one) is kept
// in memory.
RStoreWriteStream outstream;
anId = outstream.CreateLC(aStore);
// Stream out the CClassA object first
outstream << *theA;
// Stream out the CClassB object second
outstream << *theB;
// Equally we could have done:
// outstream << *theA << *theB;
// to the same effect
// Commit changes to the stream
outstream.CommitL();
// Cleanup the stream object.
// Destroy the CClassB object,
// Destroy the CClassA object,
CleanupStack::PopAndDestroy(3);
}
LOCAL_C void doRestoreL(CStreamStore& aStore,const TStreamId& anId)
{
// Construct "empty" CClassA and CClassB objects
CClassA* theA = CClassA::NewLC();
CClassB* theB = CClassB::NewLC();
// Construct and open the input stream.
// We want to access the one and only
// stream from the in-memory store.
RStoreReadStream instream;
instream.OpenLC(aStore,anId);
// Stream in the CClassA object first and
// then stream in the CClassB object. This is the order
// in which the objects were streamed out.
//
// NB the order in which the objects are streamed OUT to
// a single stream is arbitrary BUT, whatever the order
// chosen, the objects must be streamed in, in the SAME order
//
// In this example, streaming in has assignment semantics.
instream >> *theA;
instream >> *theB;
// Equally we could have done:
// outstream >> *theA >> *theB;
// to the same effect
// Cleanup the stream object
CleanupStack::PopAndDestroy();
// Show restored contents of the CClassA object
_LIT(KTxtRestoredClassA,"Restored CClassA content ...");
doShow(KTxtRestoredClassA,*theA);
// Show restored contents of the CClassB object
_LIT(KTxtRestoredClassB,"Restored CClassB content ...");
doShow(KTxtRestoredClassB,*theB);
// Destroy the CClassB object,
// Destroy the CClassA object,
CleanupStack::PopAndDestroy(2);
}
LOCAL_C void doShow(const TDesC& aHeading,const CClassA& anA)
{
console->Printf(KTxtNewLine);
console->Printf(aHeading);
console->Printf(KFormatType1,anA.iVarBuffer);
console->Printf(KFormatType2,anA.iIntValue);
console->Printf(KFormatType4,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.iFixBuffer);
console->Printf(KFormatType2,aB.iIntValue);
console->Printf(KFormatType3,aB.iUintValue);
console->Printf(KFormatType5,aB.iRealValue);
console->Printf(KTxtNewLine);
}
//***************************************************************
//***************************************************************
CClassA* CClassA::NewLC()
{
CClassA* self = new (ELeave) CClassA;
CleanupStack::PushL(self);
return self;
}
CClassA::~CClassA()
{
delete iVarBuffer;
}
void CClassA::SetTextL(const TDesC& aData)
{
iVarBuffer = aData.AllocL();
}
void CClassA::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L(iVarBuffer->Des().MaxLength());
aStream << *iVarBuffer;
aStream.WriteInt32L(iIntValue);
aStream.WriteUint32L(iUintValue);
}
void CClassA::InternalizeL(RReadStream& aStream)
{
TInt maxlen;
maxlen = aStream.ReadInt32L();
iVarBuffer = HBufC::NewL(aStream,maxlen);
iIntValue = aStream.ReadInt32L();
iUintValue = aStream.ReadUint32L();
}
//***************************************************************
//***************************************************************
CClassB* CClassB::NewLC()
{
CClassB* self = new (ELeave) CClassB;
CleanupStack::PushL(self);
return self;
}
void CClassB::ExternalizeL(RWriteStream& aStream) const
{
aStream << iFixBuffer;
aStream.WriteInt32L(iIntValue);
aStream.WriteUint32L(iUintValue);
aStream.WriteReal64L(iRealValue);
}
void CClassB::InternalizeL(RReadStream& aStream)
{
aStream >> iFixBuffer;
iIntValue = aStream.ReadInt32L();
iUintValue = aStream.ReadUint32L();
iRealValue = aStream.ReadReal64L();
}
// BLD.INF
// Component description file
//
// Copyright (c) 2000 Symbian Ltd. All rights reserved.
PRJ_MMPFILES
StreamInStore.mmp
// StreamInStore.mmp
//
// Copyright (c) 2000 Symbian Ltd. All rights reserved.
// using relative paths for source and userinclude directories
TARGET StreamInStore.exe
TARGETTYPE exe
UID 0
VENDORID 0x70000001
SOURCEPATH .
SOURCE StreamInStore.cpp
USERINCLUDE .
USERINCLUDE ..\..\CommonFramework
SYSTEMINCLUDE \Epoc32\include
LIBRARY euser.lib efsrv.lib estor.lib
The example shows objects being externalized to a single stream in a
non-persistent store. The store itself is an in-memory store represented by a
CBufStore
object.
RStoreWriteStream
: supports creation and
manipulation of a stream in a store
RStoreReadStream
: supports opening and manipulation
of a stream in a store
CBufStore
: an in-memory store