// Copyright (c) 2007-2009 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:

//

#ifndef MOCKHWRMPLUGINDATA_H

#define MOCKHWRMPLUGINDATA_H

#include <e32base.h>

#include <etel.h>

#include <etelmm.h>

#include <etelpckt.h>

#include <string.h>

#include "cmocksyengine.h"

#include <ctsy/serviceapi/cmmgsmphonestorageutility.h>

#include <ctsy/serviceapi/cmmutility.h>

#include <ctsy/serviceapi/cmmsmsutility.h>

#include <ctsy/rmmcustomapi.h>

#include "mmlist.h"

#include "pcktlist.h"

/**

enum for comparison of Serialiesed data

RBuf shouldn't be passed to Comparator, but this is done for compare 

Serialiesed data.

May be in future comparison of Serialiesed data should be changed....

*/

enum EDataTypes

	{

		EptrPhoneBookStoreEntry = 0,			// CPhoneBookStoreEntry*

		EArrayPtrSegOfPhoneBookStoreEntry		// CArrayPtrSeg<CPhoneBookStoreEntry>*

	};

/**

Class to compare 2 objects

*/

template <class T1>

class TComparator

    {

public:

    static TBool IsEqual(const T1& aData1, const T1& aData2)

        {

        // default implementation, need specialization

        return (memcmp(&aData1,&aData2,sizeof(T1))==0);

        }    

    };

/**

TComparator specialsiation for T*

*/

template <class T>

class TComparator<T*>

    {

public:

    static TBool IsEqual(const T* aData1, const T* aData2)

	    {

	    TBool result(EFalse);

		if( aData1 == aData2 )

			{

			result = ETrue;

			}

		else if ( aData1 && aData2 )

			{

		    result = TComparator<T>::IsEqual(*aData1, *aData2);

			}

	    return result;                

	    }    

    };

/**

Class to serialize objects

*/

template <class T>

class TSerializer

    {

public:

    static void SerialiseL(const T& aData, RBuf8& aBuffer)

        {

	    TPckg<T> dataPckg(aData);

    	aBuffer.Create(dataPckg);

        }    

    static void DeserialiseL(const TDesC8& aPackedData, T& aData)

		{

	    TPckg<T> dataPckg(aData);

    	dataPckg.Copy(aPackedData.Left(dataPckg.Size()));

		}

    };

/**

Class to destroy objects

*/

template <class T>

class TDestroyer

    {

public:

    static void Destroy(T& /*aData*/){}    

    };

/**

TDestroyer specialisation for T*

*/

template <class T>

class TDestroyer<T*>

    {

public:

    static void Destroy(T* aData)

    	{

    	delete aData;

    	}    

    };

/**

Class to initialise objects

*/

template <class T>

class TInitialiser

    {

public:

    static void Initialise(T& /*aData*/){}    

    };

/**

TInitialiser specialisation for CArrayPtrFlat<T>*

*/

template <class T>

class TInitialiser<T*>

    {

public:

    static void Initialise(T*& aData)

	    {

   	   	aData = NULL;

    	}

    };

/**

Class to construct objects

*/

template <class T>

class TConstructor

    {

public:

    static void ConstructL(T*& aData)

    	{

    	aData = new (ELeave) T;

    	}    

    };

/**

Class to cleanup objects

*/

template <class T>

class TCleaner

    {

public:

    static void Cleanup(TAny* self)

    	{

		TDestroyer<T*>::Destroy(static_cast<T*>(self));

    	}    

    };

/**

Data w/o params

*/

class TMockLtsyData0 : public MMockSyEngineData

    {

public: 

    IMPORT_C TBool operator == (const TDesC8& aPackedData) const;           

    };

/**

Data with 1 param

*/

template <class T1> 

class TMockLtsyData1 : public TMockLtsyData0

    {

public: 

    TMockLtsyData1(T1& aData1);

public: 

    const T1& Data1() const;

    T1* Data1Ptr();

public: 

    TBool operator == (const TDesC8& aPackedData) const;            

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

public:

	void PushL();

	virtual	void Close();

protected:

    T1& iData1;

    };

/**

Owned data with 1 param

*/  

template <class T1>

class TMockLtsyData1Buf : public TMockLtsyData1<T1>

    {

public: 

    TMockLtsyData1Buf();

public: //from TMockLtsyData1

	virtual	void Close();

private:

    T1 iData1Own;

    };

/**

Data with 2 params

*/

template <class T1, class T2>   

class TMockLtsyData2 : public TMockLtsyData1<T1>

    {

public:

    TMockLtsyData2(T1& aData1,  T2& aData2);

public: 

    const T2& Data2() const;

    T2* Data2Ptr();

public: 

    TBool operator == (const TDesC8& aPackedData) const;            

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

protected:

    T2& iData2;

    };

/**

Owned data with 2 param

*/

template <class T1, class T2>

class TMockLtsyData2Buf : public TMockLtsyData2<T1, T2>

    {

public: 

    TMockLtsyData2Buf();

public: //from TMockLtsyData1

	virtual	void Close();

private:

    T1 iData1Own;

    T2 iData2Own;

    };

/**

Data with 3 params

*/

template <class T1, class T2, class T3>   

class TMockLtsyData3 : public TMockLtsyData2<T1, T2>

    {

public:

    TMockLtsyData3(T1& aData1,  T2& aData2, T3& aData3);

public: 

    const T3& Data3() const;

    T3* Data3Ptr();

public: 

    TBool operator == (const TDesC8& aPackedData) const;            

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

protected:

    T3& iData3;

    };

/**

Owned data with 3 params

*/

template <class T1, class T2, class T3>

class TMockLtsyData3Buf : public TMockLtsyData3<T1, T2, T3>

    {

public: 

    TMockLtsyData3Buf();

public: //from TMockLtsyData1

	virtual	void Close();

private:

    T1 iData1Own;

    T2 iData2Own;

    T3 iData3Own;

    };

/**

Data with 4 params

*/

template <class T1, class T2, class T3, class T4>

class TMockLtsyData4 : public TMockLtsyData3<T1, T2, T3>

    {

public:

    TMockLtsyData4(T1& aData1,  T2& aData2, T3& aData3, T4& aData4);

public:

    const T4& Data4() const;

    T4* Data4Ptr();

public:

    TBool operator == (const TDesC8& aPackedData) const;

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

protected:

    T4& iData4;

    };

/**

Owned data with 4 params

*/

template <class T1, class T2, class T3, class T4>

class TMockLtsyData4Buf : public TMockLtsyData4<T1, T2, T3, T4>

    {

public:

    TMockLtsyData4Buf();

public: //from TMockLtsyData1

	virtual	void Close();

private:

    T1 iData1Own;

    T2 iData2Own;

    T3 iData3Own;

    T4 iData4Own;

    };

/**

Data with 5 params

*/

template <class T1, class T2, class T3, class T4, class T5>

class TMockLtsyData5 : public TMockLtsyData4<T1, T2, T3, T4>

    {

public:

    TMockLtsyData5(T1& aData1,  T2& aData2, T3& aData3, T4& aData4, T5& aData5);

public:

    const T5& Data5() const;

    T5* Data5Ptr();

public:

    TBool operator == (const TDesC8& aPackedData) const;

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

protected:

    T5& iData5;

    };

/**

Owned data with 5 params

*/

template <class T1, class T2, class T3, class T4, class T5>

class TMockLtsyData5Buf : public TMockLtsyData5<T1, T2, T3, T4, T5>

    {

public:

    TMockLtsyData5Buf();

public: //from TMockLtsyData1

	virtual	void Close();

private:

    T1 iData1Own;

    T2 iData2Own;

    T3 iData3Own;

    T4 iData4Own;

    T5 iData5Own;

    };

/**

Data with 6 params

*/

template <class T1, class T2, class T3, class T4, class T5, class T6>

class TMockLtsyData6 : public TMockLtsyData5<T1, T2, T3, T4, T5>

    {

public:

    TMockLtsyData6(T1& aData1,  T2& aData2, T3& aData3, T4& aData4, T5& aData5, T6& aData6);

public:

    const T6& Data6() const;

    T6* Data6Ptr();

public:

    TBool operator == (const TDesC8& aPackedData) const;

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

protected:

    T6& iData6;

    };

/**

Owned data with 6 params

*/

template <class T1, class T2, class T3, class T4, class T5, class T6>

class TMockLtsyData6Buf : public TMockLtsyData6<T1, T2, T3, T4, T5, T6>

    {

public:

    TMockLtsyData6Buf();

public: //from TMockLtsyData1

	virtual	void Close();

private:

    T1 iData1Own;

    T2 iData2Own;

    T3 iData3Own;

    T4 iData4Own;

    T5 iData5Own;

    T6 iData6Own;

    };

/**

Call data with w/o params params

*/

class TMockLtsyCallData0 : public MMockSyEngineData

    {

public:

    IMPORT_C TMockLtsyCallData0();

    IMPORT_C TMockLtsyCallData0(TInt aCallId, RMobilePhone::TMobileService aCallMode);

public: 

    IMPORT_C TInt CallId() const;

    IMPORT_C RMobilePhone::TMobileService CallMode() const;

public: 

    IMPORT_C TBool operator == (const TDesC8& aPackedData) const;           

    IMPORT_C void SerialiseL(RBuf8& aBuffer) const;

    IMPORT_C void DeserialiseL(const TDesC8& aPackedData);

protected:

    TInt iCallId;

    RMobilePhone::TMobileService iCallMode;

    };

/**

Call data with 1 params params

*/

template <class T1> 

class TMockLtsyCallData1 : public TMockLtsyCallData0

    {

public: 

    TMockLtsyCallData1(T1& aData1);

    TMockLtsyCallData1(TInt aCallId, RMobilePhone::TMobileService aCallMode, T1& aData1);

public:

    const T1& Data1() const;

    T1* Data1Ptr();

public: 

    TBool operator == (const TDesC8& aPackedData) const;            

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

public:

	virtual	void Close();

protected:

    T1& iData1;

    };

/**

Call data with 1 owned data params

*/

template <class T1> 

class TMockLtsyCallData1Buf : public TMockLtsyCallData1<T1>

    {

public: 

    TMockLtsyCallData1Buf();

    TMockLtsyCallData1Buf(TInt aCallId, RMobilePhone::TMobileService aCallMode);

public://from TMockLtsyCallData1

	virtual	void Close();

private:

    T1 iData1Own;

    };

/**

Call data with 2 params

*/

template <class T1, class T2>   

class TMockLtsyCallData2 : public TMockLtsyCallData1<T1>

    {

public:

    TMockLtsyCallData2(T1& aData1,  T2& aData2);

    TMockLtsyCallData2(TInt aCallId, RMobilePhone::TMobileService aCallMode, T1& aData1,  T2& aData2);

public:

    const T2& Data2() const;

    T2* Data2Ptr();

public: 

    TBool operator == (const TDesC8& aPackedData) const;            

    void SerialiseL(RBuf8& aBuffer) const;

    void DeserialiseL(const TDesC8& aPackedData);

protected:

    T2& iData2;

    };

/**

Call data with 2 owned data params

*/

template <class T1, class T2>   

class TMockLtsyCallData2Buf : public TMockLtsyCallData2<T1, T2>

    {

public: 

    TMockLtsyCallData2Buf();

    TMockLtsyCallData2Buf(TInt aCallId, RMobilePhone::TMobileService aCallMode);

public://from TMockLtsyCallData1

	virtual	void Close();

private:

    T1 iData1Own;

    T2 iData2Own;

    };

//**************************

class TPacketQoSGPRSNegotiated : public RPacketQoS::TQoSGPRSNegotiated

	{

public:

	IMPORT_C TPacketQoSGPRSNegotiated();

public: 

    IMPORT_C TBool operator == (const TPacketQoSGPRSNegotiated& aPackedData) const;            

    IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

    IMPORT_C void InternalizeL(RReadStream& aStream);

	};

class TPacketQoSR99_R4Negotiated : public RPacketQoS::TQoSR99_R4Negotiated

	{

public:

	IMPORT_C TPacketQoSR99_R4Negotiated();

public: 

    IMPORT_C TBool operator == (const TPacketQoSR99_R4Negotiated& aPackedData) const;            

    IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

    IMPORT_C void InternalizeL(RReadStream& aStream);

	};