examples/SFExamples/Symbian_OS_Explained_Hercules-v9_Example_Code/src/clientserver.cpp

// 
// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
// 
// Initial Contributors:
// Nokia Corporation - initial contribution.
// 
// Contributors:
// 
// Description:
// 
//      client-server.cpp

#include "client-server.h"
#include <s32mem.h>

EXPORT_C CHerculesData* CHerculesData::NewLC(const TDesC8& aDes1, const TDesC8& aDes2, TInt aVal)
        {
        CHerculesData* data = new (ELeave)CHerculesData(aVal);
        CleanupStack::PushL(data);
        data->ConstructL(aDes1, aDes2);
        return (data);
        }

// Creates a CHerculesData initialized with the contents of the
// descriptor parameter
CHerculesData* CHerculesData::NewLC(const TDesC8& aStreamData)
        {
        CHerculesData* data = new (ELeave)CHerculesData();
        CleanupStack::PushL(data);
        
        // Open a read stream for the descriptor
        RDesReadStream stream(aStreamData);
        CleanupClosePushL(stream);
        data->InternalizeL(stream);
        CleanupStack::PopAndDestroy(&stream); // finished with the stream
        return (data);
        }


EXPORT_C CHerculesData::~CHerculesData()
        {
        delete iDes1;
        delete iDes2;
        }

CHerculesData::CHerculesData(TInt aVal)
:       iVal(aVal){}

void CHerculesData::ConstructL(const TDesC8& aDes1, const TDesC8& aDes2)
        {
        iDes1 = aDes1.AllocL();
        iDes2 = aDes2.AllocL();
        }

        
// Creates and returns a heap descriptor which holds contents of ’this’ 
EXPORT_C HBufC8* CHerculesData::MarshalDataL() const
        {
// Create a dynamic flat buffer to hold this object's member data       
        const TInt KExpandSize = 128; // "Granularity" of dynamic buffer        
        CBufFlat* buf = CBufFlat::NewL(KExpandSize);
        CleanupStack::PushL(buf);
        RBufWriteStream stream(*buf); // Stream over the buffer
        CleanupClosePushL(stream);

        ExternalizeL(stream);
        CleanupStack::PopAndDestroy(&stream);
        
        // Create a heap descriptor from the buffer
        HBufC8* des = HBufC8::NewL(buf->Size());
        TPtr8 ptr(des->Des());
        buf->Read(0, ptr, buf->Size());
        
        CleanupStack::PopAndDestroy(buf); // Finished with the buffer
        return (des);
        }

// Writes ’this’ to aStream
void CHerculesData::ExternalizeL(RWriteStream& aStream) const
        {
        if (iDes1) // Write iDes1 to the stream (or a NULL descriptor)
                {
                aStream << *iDes1;
                }
        else
                {
                aStream << KNullDesC8;
                }

        if (iDes2) // Write iDes2 to the stream (or a NULL descriptor)
                {
                aStream << *iDes2;
                }
        else
                {
                aStream << KNullDesC8;
                }

        aStream.WriteInt32L(iVal); // Write iVal to the stream
        }

// Initializes ’this’ with the contents of aStream
void CHerculesData::InternalizeL(RReadStream& aStream)
        {
        const TInt KMaxReadSize = 1024; // Limits each descriptor to max 1024 bytes
        iDes1 = HBufC8::NewL(aStream, KMaxReadSize); // Read iDes1
        iDes2 = HBufC8::NewL(aStream, KMaxReadSize); // Read iDes2
        iVal = aStream.ReadInt32L(); // Read iVal
        }

void CHerculesData::SetDes1L(const TDesC8& aDes)
        {
        delete iDes1;
        iDes1=NULL;
        iDes1 = aDes.AllocL();
        }

void CHerculesData::SetDes2L(const TDesC8& aDes)
        {
        delete iDes2;
        iDes2=NULL;
        iDes2 = aDes.AllocL();
        }

---