// 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());

     }