sl@0: /*
sl@0: * Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies). 
sl@0: * All rights reserved.
sl@0: * This component and the accompanying materials are made available
sl@0: * under the terms of the License "Eclipse Public License v1.0"
sl@0: * which accompanies this distribution, and is available
sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: *
sl@0: * Initial Contributors:
sl@0: * Nokia Corporation - initial contribution.
sl@0: *
sl@0: * Contributors:
sl@0: *
sl@0: * Description:     
sl@0: *
sl@0: */
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // INCLUDE FILES
sl@0: #include "SortUtilJapan.h"
sl@0: #include "SortUtilImpl.h"
sl@0: #include "SortUtilImplExport.h"
sl@0: #include <jplangutil.h>
sl@0: 
sl@0: // Unnamed namespace for local definitions
sl@0: namespace
sl@0:     {
sl@0: 
sl@0:     /**
sl@0:      * Character classes for Japanese sorting, in sorting order.
sl@0:      */
sl@0:     enum TJapaneseCharClass
sl@0:         {
sl@0:         ECharClassKana,
sl@0:         ECharClassLatin,
sl@0:         ECharClassDigit,
sl@0:         ECharClassKanji,
sl@0:         ECharClassSpecial
sl@0:         };
sl@0: 
sl@0:     /**
sl@0:      * Returns the Japanese character class of aChar.
sl@0:      */
sl@0:     TJapaneseCharClass CharClass(TUint aChar)
sl@0:         {
sl@0:         const TChar ch(aChar);
sl@0:         // Special characters
sl@0:         if (ch.IsSpace() || ch.IsPunctuation() || ch.IsControl()
sl@0:             || aChar >= 0xF0000 && aChar <= 0xFFFD)
sl@0:             {
sl@0:             return ECharClassSpecial;
sl@0:             }
sl@0:         // Digit
sl@0:         else if (aChar >= '0' && aChar <= '9' ||
sl@0:             aChar >= 0xFF10 && aChar <= 0xFF19)
sl@0:             {
sl@0:             return ECharClassDigit;
sl@0:             }
sl@0:         // Latin
sl@0:         else if (aChar >= 'A' && aChar <= 'Z' ||
sl@0:             aChar >= 'a' && aChar <= 'z' ||
sl@0:             aChar >= 0x00C0 && aChar <= 0x1EF3 && aChar != 0x00D7 && aChar != 0x00F7 ||
sl@0:             aChar >= 0xFF21 && aChar <= 0xFF3A ||
sl@0:             aChar >= 0xFF41 && aChar <= 0xFF5A)
sl@0:             {
sl@0:             return ECharClassLatin;
sl@0:             }
sl@0:         // Kana
sl@0:         else if (JPLangUtil::IsKatakana(static_cast<TText>(aChar)) ||
sl@0:             JPLangUtil::IsHiragana(static_cast<TText>(aChar)))
sl@0:             {
sl@0:             return ECharClassKana;
sl@0:             }
sl@0:         // Kanji
sl@0:         else if (JPLangUtil::IsKanji(static_cast<TText>(aChar)))
sl@0:             {
sl@0:             return ECharClassKanji;
sl@0:             }
sl@0:         // All other charcters are "special"
sl@0:         else
sl@0:             {
sl@0:             return ECharClassSpecial;
sl@0:             }
sl@0:         }
sl@0: 
sl@0:     /**
sl@0:      * Compares two characters with Japanese comparison rules.
sl@0:      */
sl@0:     TInt JapaneseCompareC(TUint aLhs, TUint aRhs)
sl@0:         {
sl@0:         // First compare character classes
sl@0:         const TInt lhsCls = CharClass(aLhs);
sl@0:         const TInt rhsCls = CharClass(aRhs);
sl@0:         return lhsCls - rhsCls;
sl@0:         }
sl@0: 
sl@0:     /**
sl@0:      * Compares two strings with Japanese comparison rules.
sl@0:      */
sl@0:     TInt JapaneseCompareS(const TDesC& aLhs, const TDesC& aRhs)
sl@0:         {
sl@0:         TInt result = 0;
sl@0: 
sl@0:         const TInt minLen = Min(aLhs.Length(), aRhs.Length());
sl@0:         TInt i;
sl@0:         TInt prevCompPos(0);
sl@0:         for (i = 0; i < minLen && result == 0; ++i)
sl@0:             {
sl@0:             result = JapaneseCompareC(aLhs[i], aRhs[i]);
sl@0:             if (result == 0)
sl@0:                 {
sl@0:                 TInt orgClass = CharClass(aLhs[i]);
sl@0:                 TPtrC lPart;
sl@0:                 TPtrC rPart;
sl@0:                 if (orgClass == ECharClassKana)
sl@0:                     {
sl@0:                     int j = i;
sl@0:                     for (; j < aLhs.Length(); ++j)
sl@0:                         {
sl@0:                         if (orgClass != CharClass(aLhs[j]))
sl@0:                             {
sl@0:                             break;
sl@0:                             }
sl@0:                         }
sl@0:                     lPart.Set(aLhs.Mid(prevCompPos, j - prevCompPos));
sl@0:                     for (j = i; j < aRhs.Length(); ++j)
sl@0:                         {
sl@0:                         if (orgClass != CharClass(aRhs[j]))
sl@0:                             {
sl@0:                             break;
sl@0:                             }
sl@0:                         }
sl@0:                     rPart.Set(aRhs.Mid(prevCompPos, j - prevCompPos));
sl@0:                     result = lPart.CompareC(rPart);
sl@0:                     if (result != 0)
sl@0:                         {
sl@0:                         const TInt minKanaLen = Min(lPart.Length(), rPart.Length());
sl@0:                         TPtrC lKanaPart(lPart.Left(minKanaLen));
sl@0:                         TPtrC rKanaPart(rPart.Left(minKanaLen));
sl@0:                         TInt resultKana = lKanaPart.MatchC(rKanaPart);
sl@0:                         if (resultKana == 0)
sl@0:                             {
sl@0:                             TInt maxKanaLen = i+minKanaLen;
sl@0:                             if (i+minKanaLen+1 >= minLen)
sl@0:                                 {
sl@0:                                 if (maxKanaLen < aLhs.Length()
sl@0:                                  || maxKanaLen < aRhs.Length())
sl@0:                                     {
sl@0:                                     result = 0;
sl@0:                                     i += (minKanaLen-1);
sl@0:                                     }
sl@0:                                 else
sl@0:                                     {
sl@0:                                     result = lKanaPart.CompareC(rKanaPart);;
sl@0:                                     }
sl@0:                                 }
sl@0:                             else
sl@0:                                 {
sl@0:                                 result = 0;
sl@0:                                 i += (minKanaLen-1);
sl@0:                                 }
sl@0:                             }
sl@0:                         }
sl@0: 
sl@0:                     }
sl@0:                 else
sl@0:                     {
sl@0:                     lPart.Set(aLhs.Mid(i, 1));
sl@0:                     rPart.Set(aRhs.Mid(i, 1));
sl@0:                     result = lPart.CompareC(rPart);
sl@0:                     }
sl@0:                 }
sl@0:             else
sl@0:                 {
sl@0:                 prevCompPos = i;
sl@0:                 }
sl@0:             }
sl@0:         if (result == 0)
sl@0:             {
sl@0:             if (i < aLhs.Length())
sl@0:                 {
sl@0:                 // aLhs is longer than aRhs
sl@0:                 result += User::Collate(aLhs[i]);
sl@0:                 }
sl@0:             if (i < aRhs.Length())
sl@0:                 {
sl@0:                 // aRhs is longer that aLhs
sl@0:                 result -= User::Collate(aRhs[i]);
sl@0:                 }
sl@0:             }
sl@0:         return result;
sl@0:         }
sl@0:     }  // namespace
sl@0: 
sl@0: // Only export in DLL
sl@0: EXPORT_C MSortUtil* SortUtilFactoryFunctionL()
sl@0:     {
sl@0:     MSortUtil* util = new (ELeave) TSortUtilJapan;
sl@0:     return util;
sl@0:     }
sl@0: 
sl@0: inline TSortUtilJapan::TSortUtilJapan()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: TSortUtilJapan::~TSortUtilJapan()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: TInt TSortUtilJapan::CompareItems
sl@0:         (const MSortKeyArray& aLhs,
sl@0:         const MSortKeyArray& aRhs) const
sl@0:     {
sl@0:     TInt result(0);
sl@0:     TInt lhsIndex(0);
sl@0:     TInt rhsIndex(0);
sl@0: 
sl@0:     // Compare only pronounciation keys in the first pass
sl@0:     do
sl@0:         {
sl@0:         const TDesC& lhsText =
sl@0:             SortUtilImpl::FindNextNonEmptyKey(aLhs, ESortKeyPronounciation, lhsIndex);
sl@0:         const TDesC& rhsText =
sl@0:             SortUtilImpl::FindNextNonEmptyKey(aRhs, ESortKeyPronounciation, rhsIndex);
sl@0:         if (lhsText.Length() > 0)
sl@0:             {
sl@0:             // lhs has pronounciation key
sl@0:             if (rhsText.Length() > 0)
sl@0:                 {
sl@0:                 // Both lhs and rhs have pronounciation key: compare the key texts
sl@0:                 result = JapaneseCompareS(lhsText, rhsText);
sl@0:                 }
sl@0:             else
sl@0:                 {
sl@0:                 // Only lhs has pronounciation key
sl@0:                 result = -1;
sl@0:                 }
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             // lhs does not have pronounciation key
sl@0:             if (rhsText.Length() > 0)
sl@0:                 {
sl@0:                 // Only rhs has pronounciation key
sl@0:                 result = 1;
sl@0:                 }
sl@0:             }
sl@0: 
sl@0:         if (result != 0)
sl@0:             {
sl@0:             return result;
sl@0:             }
sl@0:         }
sl@0:     while (lhsIndex <= aLhs.SortKeyCount() && rhsIndex < aRhs.SortKeyCount());
sl@0: 
sl@0:     // No difference found with pronounciation keys: compare basic keys
sl@0:     lhsIndex = 0;
sl@0:     rhsIndex = 0;
sl@0:     do
sl@0:         {
sl@0:         const TDesC& lhsText =
sl@0:             SortUtilImpl::FindNextNonEmptyKey(aLhs, ESortKeyBasic, lhsIndex);
sl@0:         const TDesC& rhsText =
sl@0:             SortUtilImpl::FindNextNonEmptyKey(aRhs, ESortKeyBasic, rhsIndex);
sl@0:         result = JapaneseCompareS(lhsText, rhsText);
sl@0:         if (result != 0)
sl@0:             {
sl@0:             return result;
sl@0:             }
sl@0:         }
sl@0:     while (lhsIndex <= aLhs.SortKeyCount() && rhsIndex < aRhs.SortKeyCount());
sl@0: 
sl@0:     return result;
sl@0:     }
sl@0: 
sl@0: // End of file