/*

* Copyright (c) 2007 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:  Client side class to hold the result of predictive search.

*

*/

// INCLUDE FILES

#include <s32mem.h>

#include <collate.h>

#include "CPsClientData.h"

#include "CPcsDefs.h"

// ============================== MEMBER FUNCTIONS ============================

// ----------------------------------------------------------------------------

// CPsClientData::NewL

// Two Phase constructor

// ----------------------------------------------------------------------------

EXPORT_C CPsClientData* CPsClientData::NewL()

{

	CPsClientData* self = new (ELeave) CPsClientData();	

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

// ----------------------------------------------------------------------------

// CPsClientData::CPsClientData

// Default constructor

// ----------------------------------------------------------------------------

CPsClientData::CPsClientData()

{

}

// ----------------------------------------------------------------------------

// CPsClientData::ConstructL

// Two phase construction

// ----------------------------------------------------------------------------

void CPsClientData::ConstructL()

{

    iData = new (ELeave) RPointerArray<HBufC>(1);

    iDataExtension = NULL;

    iMarked = EFalse;

}

// ----------------------------------------------------------------------------

// CPsClientData::ConstructL

// Two phase construction

// ----------------------------------------------------------------------------

void CPsClientData::ConstructL(const CPsClientData& aRhs)

{

	iId = aRhs.Id();

	iUri = aRhs.Uri()->AllocL();

    iData = new (ELeave) RPointerArray<HBufC>(1);

    for(TInt i=0; i < aRhs.DataElementCount(); i++ )

    {

    	SetDataL(i,*(aRhs.Data(i)));

    }

    iFiledMatches = aRhs.FieldMatch();

    if(aRhs.DataExtension())

        {

        iDataExtension = ((HBufC8*)(aRhs.DataExtension()))->AllocL();	

        }

    if(aRhs.IsMarked())

    	iMarked = ETrue;

    else

    	iMarked = EFalse;

}

// ----------------------------------------------------------------------------

// CPsClientData::~CPsClientData

// Destructor

// ----------------------------------------------------------------------------

EXPORT_C CPsClientData::~CPsClientData()

{

	if ( iData )

	{

		iData->ResetAndDestroy();

		delete iData;

	}

	if(iDataExtension)

    {

		delete iDataExtension;

		iDataExtension = NULL;

    }

    if(iUri)

    {

    	delete iUri;

    	iUri = NULL;

    }

}

// ----------------------------------------------------------------------------

// CPsClientData::CPsClientData

// Returns the clone of this object

// ----------------------------------------------------------------------------

EXPORT_C CPsClientData* CPsClientData::CloneL() const

{

	CPsClientData* clone = new (ELeave) CPsClientData();	

    CleanupStack::PushL(clone);

    clone->ConstructL(*this);

    CleanupStack::Pop();

    return clone;

}

// ----------------------------------------------------------------------------

// CPsClientData::Id

// Returns the unique id

// ----------------------------------------------------------------------------

EXPORT_C  TInt CPsClientData::Id() const

{

    return iId;

}

// ----------------------------------------------------------------------------

// CPsClientData::SetId

// Sets the unique id

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::SetId (const TInt aId)

{

	iId = aId;

}

// ----------------------------------------------------------------------------

// CPsClientData::Uri

// Returns the unique URI

// ----------------------------------------------------------------------------

EXPORT_C  HBufC* CPsClientData::Uri() const

{

    return iUri;

}

// ----------------------------------------------------------------------------

// CPsClientData::SetUriL

// Sets the unique URI

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::SetUriL(const TDesC& aUri)

{

	iUri = aUri.AllocL();

}

// ----------------------------------------------------------------------------

// CPsClientData::Data

// Returns the data

// ----------------------------------------------------------------------------

EXPORT_C HBufC* CPsClientData::Data(TInt aIndex) const

{

    if ( aIndex >= iData->Count() )    

         return NULL;

    return (*iData)[aIndex];

}

// ----------------------------------------------------------------------------

// CPsClientData::SetDataL

// Sets the data

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::SetDataL(TInt /*aIndex*/, const TDesC& aData)

{   

    iData->AppendL(aData.AllocL());

}

// ----------------------------------------------------------------------------

// CPsClientData::DataElementCount

// 

// ----------------------------------------------------------------------------

EXPORT_C TInt CPsClientData::DataElementCount() const

{

	return (iData->Count());

}

// ----------------------------------------------------------------------------

// CPsClientData::ExternalizeL

// Writes 'this' to aStream

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::ExternalizeL(RWriteStream& aStream) const

{

    aStream.WriteInt16L(iId); // Write unique ID to the stream

    aStream.WriteUint8L(iFiledMatches); // Field Matches

    aStream.WriteUint8L(iUri->Size());  // write URI length to stream

    aStream<<*iUri;                      // write URI to stream

    aStream.WriteUint8L(iData->Count()); // Number of data elements

	for ( int index = 0; index < iData->Count(); index++ )

	{

	    HBufC* data = (*iData)[index];

	    if ( data ) // Write data to the stream (or a NULL descriptor)

	    {

	      	aStream.WriteInt16L( data->Size() ); // data size

			aStream << *data; // data

	    }

	    else

	    {

	    	aStream.WriteInt16L( 0 );

	    	aStream << KNullDesC;

	    }

	}

	if ( iDataExtension )

    {

        HBufC8* dataExt = (HBufC8*)iDataExtension;

    	aStream.WriteUint8L( dataExt->Size() );

    	aStream << *dataExt;

    }

    else 

    {

    	aStream.WriteUint8L( 0 );

    	aStream << KNullDesC8;	    	

    }

}

// ----------------------------------------------------------------------------

// CPsClientData::InternalizeL

// Initializes 'this' with the contents of aStream

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::InternalizeL(RReadStream& aStream)

{

    // Read unique id

    TInt tmp = aStream.ReadInt16L();

    iId = tmp;

    // Read Field Match

	iFiledMatches  = aStream.ReadUint8L();

    // Read the URI length

    TUint8 len = aStream.ReadUint8L();

    // read uri

    iUri = HBufC::NewL(aStream, len);

    // Read number of data elements

    TInt szNumElements = aStream.ReadUint8L();

    for ( int index = 0; index < szNumElements; index++ )

    {

        // Read data size

	    TInt szData = aStream.ReadInt16L();

    	HBufC* data =  HBufC::NewL(aStream, szData);

	    iData->InsertL(data, index);

    }

	// Read data extension size

	TUint8 szDataExt = aStream.ReadUint8L();

    if(iDataExtension)

    {

         delete iDataExtension;

        iDataExtension = NULL;

    }

    HBufC8* dataExt =  HBufC8::NewL(aStream, szDataExt);

    iDataExtension = dataExt;

}

// ----------------------------------------------------------------------------

// CPsClientData::DataExtension

// 

// ----------------------------------------------------------------------------

EXPORT_C TAny* CPsClientData::DataExtension() const

{

	return iDataExtension;

}

// ----------------------------------------------------------------------------

// CPsClientData::SetDataExtensionL

// 

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::SetDataExtensionL(TAny* aDataExt)

{

	if(aDataExt == NULL)

		return;

	HBufC8* dataExt = (HBufC8*)aDataExt;

	iDataExtension = dataExt->AllocL();

}

// ----------------------------------------------------------------------------

// CPsClientData::SetBookMark

// 

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::SetMark()

{

	iMarked = ETrue;

}

// ----------------------------------------------------------------------------

// CPsClientData::SetBookMark

// 

// ----------------------------------------------------------------------------

EXPORT_C TBool CPsClientData::IsMarked() const

{

	return iMarked;

}

// ----------------------------------------------------------------------------

// CPsClientData::SetFieldMatch

// 

// ----------------------------------------------------------------------------

EXPORT_C void CPsClientData::SetFieldMatch(TUint8 aFieldMatch)

{	

	iFiledMatches = aFieldMatch;

}

// ----------------------------------------------------------------------------

// CPsClientData:FieldMatch

// Return the Field match attribute

// ----------------------------------------------------------------------------		

EXPORT_C TUint8 CPsClientData::FieldMatch() const

{

    return iFiledMatches;

}