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

// Started by Brendan, January 1996

// Descended from HCIMATCH.CPP

// Incremental matcher class

// 

//

#include <bamatch.h>

#include <baflpan.h>

#include <bamdesca.h>

EXPORT_C RTextBuf::RTextBuf()

	: iPtr(NULL,0), iText(NULL)

/** Default constructor. */

	{}

EXPORT_C RTextBuf::~RTextBuf()

/** Destructor. */

	{

	Close();

	}

EXPORT_C void RTextBuf::SetMaxLengthL(TInt aMaxLength)

/** Sets the maximum length of the text that the object can store.

Attempts to store text beyond the maximum length cause a panic, as

with descriptors. */

    {

   	__ASSERT_ALWAYS(aMaxLength>0,Panic(EBafPanicTextBufOutOfRange));

	Close();

	iText=new(ELeave) TText[aMaxLength+1];

	iPtr.Set(iText,0,aMaxLength);

	}

EXPORT_C void RTextBuf::Close()

	{

	delete [] iText;

	iText=NULL;

	iPtr.Set(NULL,0,0);

   	}

// class RIncrMatcherBase

EXPORT_C RIncrMatcherBase::~RIncrMatcherBase()

/** Virtual destructor, for reimplementation by derived classes. */

	{}

TBool RIncrMatcherBase::DoIsMatch(const TDesC& aQuery,TCompareFunc aCompare) const

	{

	const TDes& des=MatchDes();

	TInt l=des.Length();

	return l>aQuery.Length() ? EFalse : aCompare(aQuery.Ptr(),l,des.Ptr(),l)==0;

	}

TInt RIncrMatcherBase::DoFirstMatchingIndex(TInt& aIndex,const MDesCArray& aDesArray,TCompareFunc aCompare) const

	{

	TInt noElements=aDesArray.MdcaCount();

	__ASSERT_ALWAYS(aIndex>=0 && aIndex<noElements,Panic(EBafPanicMatcherOutOfRange));

	do

		{

		if (DoIsMatch(aDesArray.MdcaPoint(aIndex),aCompare))

			return KErrNone;

		} while (++aIndex<noElements);

	return KErrNotFound;

	}

void RIncrMatcherBase::DoSetBestMatch(const TDesC& aBuf,TCompareFunc aCompare)

	{

	TDes& des=MatchDes();

	des.SetLength(Min(des.Length(),aBuf.Length()));

	while (!DoIsMatch(aBuf,aCompare))

		DeleteLastChar();

	}

EXPORT_C TBool RIncrMatcherBase::IsMatch(const TDesC& aQuery) const

/**Tests for match, using a binary comparison.

@param aQuery Text to match

@return  ETrue if match found, else EFalse */

    {

	return DoIsMatch(aQuery,Mem::Compare);

	}

EXPORT_C TBool RIncrMatcherBase::IsMatchC(const TDesC& aQuery) const

/** Tests for match, using locale collation rules.

@param aQuery  Text to match

@return ETrue if match found, else EFalse */

    {

	return DoIsMatch(aQuery,Mem::CompareC);

	}

EXPORT_C TBool RIncrMatcherBase::IsMatchF(const TDesC& aQuery) const

/** Tests for match, using locale folding rules.

@param    aQuery  Text to match

@return  ETrue if match found, else EFalse */

	{

	return DoIsMatch(aQuery,Mem::CompareF);

	}

EXPORT_C TInt RIncrMatcherBase::FirstMatchingIndex(TInt& aResultIndex,const MDesCArray& aDesArray,TInt aStartIndex) const

/** Finds the first match in an array, using a binary comparison.

@param aResult On return, index of the first match in aDesArray 

@param aDesArray  Array of descriptors to search

@param aStartIndex Index of aDesArray at which to begin  search

@return  KErrNone if success or KErrNotFound if no match is found */

	{

	aResultIndex=aStartIndex;

	return DoFirstMatchingIndex(aResultIndex,aDesArray,Mem::Compare);

	}

EXPORT_C TInt RIncrMatcherBase::FirstMatchingIndexC(TInt& aResultIndex,const MDesCArray& aDesArray,TInt aStartIndex) const

/** Finds the first match in an array, using locale collation rules.

@param aResult  On return, index of the first match in aDesArray 

@param aDesArray Array of descriptors to search

@param aStartIndex Index of aDesArray  at which to begin search

@return  KErrNone if success or KErrNotFound if no match is found */

    {

	aResultIndex=aStartIndex;

	return DoFirstMatchingIndex(aResultIndex,aDesArray,Mem::CompareC);

	}

EXPORT_C TInt RIncrMatcherBase::FirstMatchingIndexF(TInt& aResultIndex,const MDesCArray& aDesArray,TInt aStartIndex) const

/** Finds the first match in an array, using locale folding rules.

@param aResult  On return, index of the first match in aDesArray

@param     aDesArray Array of descriptors to search

@param     aStartIndex Index of aDesArray at which to begin search

@return  KErrNone if success or KErrNotFound if no match is found */

    {

	aResultIndex=aStartIndex;

	return DoFirstMatchingIndex(aResultIndex,aDesArray,Mem::CompareF);

	}

EXPORT_C void RIncrMatcherBase::SetBestMatch(const TDesC& aBuf)

/** Sets the match text to the best match between the match text and the passed 

buffer, using a binary comparision.

For example, if the original match text is "goose" and the passed buffer is 

"gooSE", the match text would be changed to "goo".

@param aBuf Text to match */

	{

	DoSetBestMatch(aBuf,Mem::Compare);

	}

EXPORT_C void RIncrMatcherBase::SetBestMatchC(const TDesC& aBuf)

/** Sets the match text to the best match between the match text and the passed 

buffer, using locale collation rules.

@param aBuf Text to match */

	{

	DoSetBestMatch(aBuf,Mem::CompareC);

	}

EXPORT_C void RIncrMatcherBase::SetBestMatchF(const TDesC& aBuf)

/** Sets the match text to the best match between the match text and the passed 

buffer, using locale folding rules.

@param aBuf Text to match */

	{

	DoSetBestMatch(aBuf,Mem::CompareF);

	}

EXPORT_C void RIncrMatcherBase::AppendChar(TChar aLetter)

/** Appends a character to the end of the match text.

@param aLetter Character to append */

	{

	TDes& des=MatchDes();

	__ASSERT_ALWAYS(des.Length()<des.MaxLength(),Panic(EBafPanicMatcherOutOfRange));

	des.Append(aLetter);

	}

EXPORT_C void RIncrMatcherBase::DeleteLastChar()

/** Deletes the final character in the match text. */

	{

	TDes& des=MatchDes();

	TInt l=des.Length();

	if (--l>=0)

		{

		des[l]=0;

		des.SetLength(l);

		}

	}

EXPORT_C RIncrMatcherPtr::RIncrMatcherPtr()

    : iDesPtr(NULL)

/** Default constructor. */

    {

    }

EXPORT_C RIncrMatcherPtr::RIncrMatcherPtr(TDes& aDes)

    : iDesPtr(&aDes)

/** Constructor that initialises the object with the text to be matched against.

@param aDes Text to be matched against */

    {

    }

EXPORT_C RIncrMatcherPtr::~RIncrMatcherPtr()

/** Destructor. */

    {

    }

EXPORT_C TDes& RIncrMatcherPtr::MatchDes()

/** Gets the match text.

@return Match text */

    {

    return(*iDesPtr);

    }

EXPORT_C const TDes& RIncrMatcherPtr::MatchDes() const

/** Gets the match text.

@return Match text */

    {

    return(*iDesPtr);

    }

EXPORT_C RIncrMatcherTextBuf::RIncrMatcherTextBuf()

/** Default constructor. */

    {

    }

EXPORT_C RIncrMatcherTextBuf::~RIncrMatcherTextBuf()

/** Destructor.*/

    {

    }

EXPORT_C TDes& RIncrMatcherTextBuf::MatchDes()

/** Gets the match text.

@return Match text */

    {

    return(iTextBuf.Text());

    }

EXPORT_C const TDes& RIncrMatcherTextBuf::MatchDes() const

/** Gets the match text.

@return Match text */

   {

    return(iTextBuf.Text());

    }