// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// Folding and decomposition implementation
// 
//

#ifndef __COMPAREIMP_H__
#define __COMPAREIMP_H__

#include <e32std.h>
#include <unicode.h>

//Forward declarations
class TUTF32Iterator;

//////////////////////////////////////////////////////////////////////////////////////////////
// Global functions
//////////////////////////////////////////////////////////////////////////////////////////////

TChar UTF16ToChar(const TText16* a);
TBool IsBaseCharacter(TChar);

TBool MatchSectionFolded(TUTF32Iterator& aCandidateString, TUTF32Iterator& aSearchTerm);

TBool FindMatchSectionFolded(TUTF32Iterator& aCandidateString, TUTF32Iterator& aSearchTerm);

TBool MatchStringFolded(const TText16* aCandidateStringStart, const TText16* aCandidateStringEnd,
                        const TText16* aSearchTermStart, const TText16* aSearchTermEnd);

TInt LocateMatchStringFolded(const TText16* aCandidateStringStart, const TText16* aCandidateStringEnd,
                             const TText16* aSearchTermStart, const TText16* aSearchTermEnd);

TInt FindFolded(TUTF32Iterator& aCandidateString, TUTF32Iterator& aSearchTerm);

TInt CompareFolded(const TUTF32Iterator& aLeft, const TUTF32Iterator& aRight);

TInt CombineAsMuchAsPossible(const TDesC16& aDes, TChar& aCombined);

TBool DecomposeChar(TChar aCh, TPtrC16& aResult);

inline void SkipCombiningCharacters(TUTF32Iterator& aUTF32It);

/**
Converts UTF16 into UTF32, ignoring non-characters and
unpaired surrogates and combining paired surrogates.
@internalComponent
*/
class TUTF32Iterator
	{
public:
	enum TStartsWithValidCharacter { EStartsWithValidCharacter };
	inline TUTF32Iterator();
	inline explicit TUTF32Iterator(const TText16* aSingleton);
	inline TUTF32Iterator(const TText16* aStart, const TText16* aEnd);
	inline TUTF32Iterator(const TText16* aStart, const TText16* aEnd, TStartsWithValidCharacter);

	inline TUTF32Iterator CurrentAsIterator() const;
	inline TBool AtEnd() const;
	void Next();
	inline TChar Current() const;
	TBool LocateFoldedBaseCharacter(TChar aChar);
	inline const TText16* CurrentPosition() const;
	inline TInt Length() const;
	inline TInt operator[](TInt) const;
	inline void SetStart(const TText16*);
private:
	const TText16* iStart;
	const TText16* iEnd;
	TChar iCurrent;
	};

//////////////////////////////////////////////////////////////////////////////////////////////
// FOLDING
//////////////////////////////////////////////////////////////////////////////////////////////

/**
@internalComponent
*/
class TFoldedDecompIterator
	{
public:
	inline TFoldedDecompIterator();
	explicit TFoldedDecompIterator(const TUTF32Iterator&);
	inline void Set(const TUTF32Iterator&);
	TBool AtEnd() const;
	TBool AtEndOrWildcard() const;
	TBool EnterFoldedSequence();
	TBool StrictEnterFoldedSequence();
	inline TBool IsInFoldedSequence() const;
	TBool CurrentIsBaseFoldedFromCombiner() const;
	TChar Current() const;
	TBool Match(TChar aCode);
	TBool Match(TFoldedDecompIterator& aThat);
	void Next();
	inline TUTF32Iterator BaseIterator() const;
private:
	TUTF32Iterator iOriginal;
	TUTF32Iterator iFolded;
	};

/**
Sorts sequences of combining characters with non-zero combining classes into
order of their combining classes.
@internalComponent
*/
class TFoldedSortedDecompIterator
	{
public:
	inline TFoldedSortedDecompIterator();
	TInt Set(TFoldedDecompIterator &aBase);
	void Set();
	TBool AtEnd() const;
	TChar Current() const;
	void Next();

private:
	TFoldedDecompIterator iStart; // Starting code.	
	TInt iLength; // Length in decomposed codes.
	TFoldedDecompIterator iCurrent; // Current code.
	TInt iCurrentCount; // Number of decomposed codes iCurrent is past iStart
	TInt iCurrentClass; // Current class being searched for.
	TInt iRemaining; // Number of Next()s left
	};

/**
Iterator that outputs canonically decomposed folded strings.
This is much slower than using the matching functions, so should only
be used where an ordering is required.
@internalComponent
*/
class TFoldedCanonicalIterator
	{
public:
	TFoldedCanonicalIterator(const TUTF32Iterator&);
	TBool AtEnd() const;
	TChar Current() const;
	void Next(const TUnicodeDataSet* aCharDataSet);
private:
	TFoldedDecompIterator iBase;
	TFoldedSortedDecompIterator iSorted;
	};


//////////////////////////////////////////////////////////////////////////////////////////////
// COLLATION
//////////////////////////////////////////////////////////////////////////////////////////////

/**
@internalComponent
*/
class TDecompositionIterator
	{
public:
	inline TDecompositionIterator();
	void Set(const TUTF32Iterator&);
	explicit TDecompositionIterator(const TUTF32Iterator&);
	TBool AtEnd() const;
	TChar Current() const;
	void Next();
	const TText16* CurrentPosition() const;
private:
	TUTF32Iterator iBase;
	TUTF32Iterator iDecomposition;
	};

/**
@internalComponent
*/
class TCanonicalDecompositionIterator
	{
public:
	inline TCanonicalDecompositionIterator();
	void Set(const TUTF32Iterator&);
	TBool AtEnd() const;
	TChar Current() const;
	void Next();
	const TText16* CurrentPositionIfAtCharacter() const;
	TBool IsInOpenSequence() const;
private:
	TDecompositionIterator iBase;
	// iBase.CurrentPosition() before the last move
	const TText16* iLastPosition;
	// If iCurrent is active, iCurrentCombiningClass
	// is nonzero, and represents the combining class
	// of the character it points to.
	TInt iCurrentCombiningClass;
	// contains true if more characters added to the end may change
	// the characters currently being output
	TBool iInOpenSequence;
	// Iterator that looks for characters to be sorted.
	TDecompositionIterator iCurrent;
	};

/**
Iterator that gives the canonically decomposed form of
its input, and allows a limited amount of look-ahead (i.e.
peeking further into the decomposition without moving
the iterator)
@internalComponent
*/
class TCanonicalDecompositionIteratorCached
	{
public:
	void Set(const TUTF32Iterator&);
	TBool AtEnd() const;
	// Advance aOffset characters.
	void Next(TInt aOffset);
	// Get the character at the position of the iterator plus aOffset steps.
	// Returns FFFF if we are looking too far ahead.
	TChar Get(TInt aOffset);
	// If the current position in the original string is representable
	// as a pointer into it and we know what it is, return it.
	const TText16* CurrentPositionIfAtCharacter() const;
private:
	// KMaxLookAhead must be a power of 2
	enum { KMaxLookAhead = 8 };
	TCanonicalDecompositionIterator iBase;
	struct TCache
		{
		TChar iChar;
		const TText16* iPos;
		};
	TCache iCache[KMaxLookAhead + 1];
	TInt iCacheStart;
	TInt iCacheSize;
	};

#include "compareimp.inl"

#endif //__COMPAREIMP_H__