/*

* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

* MSRP Implementation

*

*/

#ifndef __MMSRPBUFFER_H

#define __MMSRPBUFFER_H

// INCLUDES

#include <e32base.h>

#include "MsrpCommon.h"

// CLASS DECLARATIONS

class RMsrpBuf;

class CMSRPBuffer;

class CMSRPBufPool;

/**

 * pool of buffers

 */

class CMSRPBufPool : public CBase

    {

    friend class CMSRPBuffer;     

public: 

    inline RMsrpBuf ProvideBufferL(TInt aSize = KBufSize);

    //inline RMsrpBuf ProvideBufferL(TInt aSize);

    //InitializePool; //dummy

    //void ReleasePool(); //force free all buffers

    inline virtual ~CMSRPBufPool();

private:

    inline void TakeBackBufferL(CMSRPBuffer* aBuffer); //append to pool

private:    

    RPointerArray<CMSRPBuffer> iFreeBufPool; //free buf pool

    RPointerArray<CMSRPBuffer> iUsedBufPool; //free buf pool

    };

/**

* The buffer class

*/

class CMSRPBuffer : public CBase

    {

friend class RMsrpBuf;  

    public:

        inline static CMSRPBuffer* NewL(TInt aSize, CMSRPBufPool& aPool );        

        inline virtual ~CMSRPBuffer();

    private:

        inline void ConstructL(TInt aSize);

        inline CMSRPBuffer(CMSRPBufPool& aPool);

        TPtr8 MsrpDes(TInt aOffset);

        TPtr8 MsrpDes();

        inline void IncRef(void);           

        inline void DecRef(void);

    private:

        TUint iRef;

        HBufC8* iBuf;

        CMSRPBufPool& iBufPool;

    };

class RMsrpBuf

    {

    public:    

    inline RMsrpBuf(CMSRPBuffer& aBuf);

    inline RMsrpBuf(RMsrpBuf& aClone, TPtr8 aPtr);

    //get a R ref on the C class using the R class //MidTPtr

    inline RMsrpBuf(const RMsrpBuf& aCopy);

    //makes the rmsrpbuf point to the remaining buffer after the length  

    TInt MsrpRightExtract();

    //if same pool then append to our Rmsrpbuf and return true

    //no continuity check, not required as of now

    inline TBool Collate(RMsrpBuf& aSuffix);

    inline void MsrpRightTPtr(TInt length);

    inline void MsrpLeftTPtr(TInt length);

    inline void MsrpMidTPtr(TInt offset);

    inline void MsrpMidTPtr(TInt offset, TInt length);

    inline void Zero();

    inline void Append(TDesC8& aDes);

    /*implicit TPtr conv, temp only*/

    inline operator TPtr8() const;

    inline operator TPtr8&();

    /**

     * if TPtrs are passed to and stored in some class obj

     * then the passer must call close on rbuf after the obj has cleaned up itself or 

     *  released the reference 

     */

    inline TPtr8 Ptr();

    inline virtual ~RMsrpBuf();

    private:

        //assignment

        RMsrpBuf& operator=(const RMsrpBuf&);

    private:

        CMSRPBuffer& iBuf;

        TPtr8 iPtr;    

    };

    inline RMsrpBuf CMSRPBufPool::ProvideBufferL(TInt aSize) //remove head element of pool or allocate and provide

        {

        CMSRPBuffer* buf = NULL;

        if (iFreeBufPool.Count())

            {

            buf = iFreeBufPool[0];

            iFreeBufPool.Remove(0);

            }

        else

            {

            buf = CMSRPBuffer::NewL(aSize, *this);

            }

        CleanupStack::PushL(buf);

        iUsedBufPool.AppendL(buf); 

        CleanupStack::Pop();

        RMsrpBuf ptr(*buf);

        return ptr;

        }

    inline CMSRPBufPool::~CMSRPBufPool()

        {

        iFreeBufPool.ResetAndDestroy();

        iFreeBufPool.Close();

        iUsedBufPool.ResetAndDestroy();

        iUsedBufPool.Close();

        }

    inline void CMSRPBufPool::TakeBackBufferL(CMSRPBuffer* aBuffer) //append to pool

        {

        TInt index = iUsedBufPool.Find(aBuffer);    

        iUsedBufPool.Remove(index);

        CleanupStack::PushL(aBuffer);

        iFreeBufPool.AppendL(aBuffer);

        CleanupStack::Pop(aBuffer);

        }

/**

* The buffer class

*/

        inline CMSRPBuffer* CMSRPBuffer::NewL(TInt aSize, CMSRPBufPool& aPool )

            {

            CMSRPBuffer* self = new (ELeave) CMSRPBuffer(aPool );

            CleanupStack::PushL(self);

            self->ConstructL(aSize);

            CleanupStack::Pop(self);

            return self;

            }

        inline CMSRPBuffer::CMSRPBuffer(CMSRPBufPool& aPool ): iBufPool(aPool)

            {

            }

        inline void CMSRPBuffer::ConstructL(TInt aSize)

           {

           iBuf = HBufC8::NewL(aSize);

           }

        inline CMSRPBuffer::~CMSRPBuffer()

            {

            delete iBuf;

            }      

        inline TPtr8 CMSRPBuffer::MsrpDes(TInt aOffset) //MsrpRef

            {

            TPtr8 mPtr(iBuf->Des());

            mPtr.Set(mPtr.MidTPtr(aOffset));

            return mPtr;

            }

        inline TPtr8 CMSRPBuffer::MsrpDes() //MsrpRef

            {

            return iBuf->Des();            

            }

        inline void CMSRPBuffer::IncRef(void)

            {

            iRef++;

            }

        inline void CMSRPBuffer::DecRef(void)

            {

            iRef--;

            if (iRef == 0)

                iBufPool.TakeBackBufferL(this);

                //delete this;                

            }

    inline RMsrpBuf::RMsrpBuf(CMSRPBuffer& aBuf):iBuf(aBuf), iPtr(aBuf.MsrpDes())    

        {

        iBuf.IncRef();                 

        }

    inline RMsrpBuf::RMsrpBuf(RMsrpBuf& aClone, TPtr8 aPtr):iBuf(aClone.iBuf), iPtr(aPtr) 

        {

        //check TPtr belongs to buf

        //if(iBuf.IsInBuf(aPtr))//DEBUG

        iBuf.IncRef();

        //iPtr = aPtr;         

        }

    //get a R ref on the C class using the R class //MidTPtr

    inline RMsrpBuf::RMsrpBuf(const RMsrpBuf& aCopy):iBuf(aCopy.iBuf), iPtr(aCopy.iPtr)

        {        

        iBuf.IncRef();

        }

    inline TInt RMsrpBuf::MsrpRightExtract()

        {

        TInt length = iPtr.Length();

        iPtr.SetMax();

        iPtr.Set(iPtr.MidTPtr(length));     

        iPtr.Zero();

        return iPtr.MaxLength();

        }

    inline TBool RMsrpBuf::Collate(RMsrpBuf& aSuffix)

        {

        if (&aSuffix.iBuf != &iBuf)

            return FALSE;

        iPtr.SetLength(iPtr.Length() + aSuffix.iPtr.Length());      

        return TRUE;

        }

    inline void RMsrpBuf::MsrpRightTPtr(TInt length)

        {

        iPtr.Set(iPtr.RightTPtr(length));    

        }

    inline void RMsrpBuf::MsrpLeftTPtr(TInt length)

        {

        iPtr.Set(iPtr.LeftTPtr(length));    

        }

    inline void RMsrpBuf::MsrpMidTPtr(TInt offset)

        {

        TInt length = iPtr.Length();

        iPtr.SetMax();

        iPtr.Set(iPtr.MidTPtr(offset));     

        iPtr.SetLength(length - offset);  

        }

    inline void RMsrpBuf::MsrpMidTPtr(TInt offset, TInt length)

        {

        iPtr.Set(iPtr.MidTPtr(offset, length));    

        }

    inline void RMsrpBuf::Zero()

        {

        iPtr.Zero();    

        }

    inline void RMsrpBuf::Append(TDesC8& aDes)

        {

        iPtr.Append(aDes);    

        }

    /*implicit TPtr conv, temp only*/

    inline RMsrpBuf::operator TPtr8() const

        {

        return iPtr;        

        }

    inline RMsrpBuf::operator TPtr8&()

        {

        return iPtr;        

        }

    /**

     * if TPtrs are passed to and stored in some class obj

     * then the passer must call close on rbuf after the obj has cleaned up itself or 

     *  released the reference 

     */

    inline TPtr8 RMsrpBuf::Ptr()

        {

        return iPtr;

        }

    inline RMsrpBuf::~RMsrpBuf()

    //inline void Close()

        {

        iBuf.DecRef();

        iPtr.Zero();

        //iBuf = 0;

        }

#endif // __MMSRPBUFFER_H

// End of file