// 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:

 //

 #include <langutil.h>

 #include "T_LangUtilsTestShareFunc.h"

 void DoCopyFileL(RFs& aFs, const TDesC& aSourceFullName, const TDesC& aTargetFullName, TUint aSwitch)

     {

     CFileMan* fileMan=CFileMan::NewL(aFs);

     CleanupStack::PushL(fileMan);

     User::LeaveIfError(fileMan->Copy(aSourceFullName,aTargetFullName,aSwitch));

     CleanupStack::PopAndDestroy(); // fileMan

     }

 TInt LangUtilsTest::CopyFile(RFs& aFs, const TDesC& aSourceFullName, const TDesC& aTargetFullName, TUint aSwitch)

 /** Copies one or more files.

 For more details, 

 @see CFileMan::Copy()

 @since     5.1

 @param     aFs File server session

 @param     aSourceFullName Path indicating the file(s) to be copied. Any path

 components that are not specified here will be taken from the session path.

 @param     aTargetFullName Path indicating the directory into which the file(s)

 are to be copied

 @param     aSwitch=CFileMan::EOverWrite Set this to zero for no overwriting and 

 no recursion; CFileMan::EOverWrite to overwrite files with the same name; or 

 CFileMan::ERecurse for recursion.

 @return   KErrNone if successful, otherwise another of the system-wide error 

 codes.*/

     {

     TRAPD(err,DoCopyFileL(aFs,aSourceFullName,aTargetFullName,aSwitch));

     return err;

     }

 TBool LangUtilsTest::FileExists(const RFs& aFileSession,const TDesC& aFileName)

 /** Checks if the specified file exists.

 @param aFs File server session

 @param aFileName File to check

 @return ETrue if the file exists, otherwise EFalse */

     { // static

     TEntry entry;

     return(aFileSession.Entry(aFileName,entry)==KErrNone);

     }

 void DoDeleteFileL(RFs& aFs, const TDesC& aSourceFullName, TUint aSwitch)

     {

     CFileMan* fileMan=CFileMan::NewL(aFs);

     CleanupStack::PushL(fileMan);

     User::LeaveIfError(fileMan->Delete(aSourceFullName,aSwitch));

     CleanupStack::PopAndDestroy(); // fileMan

     }

 EXPORT_C TInt LangUtilsTest::DeleteFile(RFs& aFs, const TDesC& aSourceFullName, TUint aSwitch)

 /** Deletes one or more files.

 For more details,

 @see CFileMan::Delete().

 @since 5.1

 @param aFs File server session

 @param aSourceFullName Path indicating the file(s) to be deleted. May either

 be a full path, or relative to the session path. Use wildcards to specify 

 more than one file.

 @param aSwitch=0  Specify CFileMan::ERecurse for recursion,

 zero for no recursion.

 @return KErrNone if successful, otherwise another of the system-wide error 

 codes. */   

     {

     TRAPD(err,DoDeleteFileL(aFs,aSourceFullName,aSwitch));

     return err;

     }

 NONSHARABLE_CLASS(TKeyDesC16Array) : public TKeyArrayFix

     {

 public:

     TKeyDesC16Array(TKeyCmpText aType);

 private: // from TKey

     TInt Compare(TInt aLeft,TInt aRight) const;

     };

 TKeyDesC16Array::TKeyDesC16Array(TKeyCmpText aType)

     : TKeyArrayFix(0,aType,0)

     {

     }

 TInt TKeyDesC16Array::Compare(TInt aLeft,TInt aRight) const

     {

     TDesC16* left=(*(TDesC16**)At(aLeft));

     TDesC16* right=(*(TDesC16**)At(aRight));

     switch (iCmpType)

         {

     case ECmpFolded:

         return(left->CompareF(*right));

     case ECmpCollated:

         return(left->CompareC(*right));

     default:

         break;

         }

     return(left->Compare(*right));

     }

 EXPORT_C CDesC16Array::CDesC16Array(TBufRep aRep,TInt aGranularity)

     : CArrayFixBase(aRep,sizeof(HBufC16*),aGranularity)

     {

     }

 EXPORT_C CDesC16Array::~CDesC16Array()

 /** Frees all resources owned by the object, prior to its destruction. In particular, 

 it deletes all descriptors from the array and frees the memory allocated to 

 the array buffer. */

     {

     Reset();

     }

 EXPORT_C void CDesC16Array::Reset()

 /** Deletes all descriptors from the array and frees the memory allocated to the 

 array buffer.

 @see CDesC16Array::Delete() */

     {

     Delete(0,Count());

     }

 EXPORT_C void CDesC16Array::Delete(TInt aIndex)

     {

     Delete(aIndex,1);

     }

 /**

  *

  * Deletes one or more logically contiguous descriptor elements from the

  * array.

  *

  * The deletion starts at the specified position.Deleting descriptor

  * elements from the array frees the memory occupied by the associated

  * heap descriptors and removes their pointers from the array buffer but

  * does not cause the array buffer to be automatically compressed. Call

  * the Compress() function to return excess space in the array buffer to

  * the heap.

  *

  * @param     " TInt aPos "

  *            The starting position in the array from which

  *            descriptor elements are to be deleted. The position is

  *            relative to zero, i.e. zero implies the first

  *            descriptor element. This value must not be negative

  *            and must not be greater than the number of descriptor

  *            elements currently in the array, otherwise the

  *            functions raise an E32USER-CBase 21 panic.

  * @param     " TInt aCount "

  *            If specified, the number of contiguous descriptor

  *            elements to be deleted from the array. This value must

  *            not be negative otherwise the function raises an

  *            E32USER-CBase 22 panic. This value must not be

  *            negative otherwise the function raises an

  *            E32USER-CBase 22 panic. This value must not be

  *            negative otherwise the function raises an

  *            E32USER-CBase 22 panic. This value plus the value of

  *            the starting position must not be greater than the

  *            number of descriptor elements in the array, otherwise

  *            the function raises an E32USER-CBase 29 panic. If not

  *            specified, one element is assumed.

  */

 EXPORT_C void CDesC16Array::Delete(TInt aIndex,TInt aCount)

     {

     TInt count=aCount;

     for (TInt ii=aIndex; count--; ii++)

         User::Free(*(HBufC16**)At(ii));

     CArrayFixBase::Delete(aIndex,aCount);

     }

 EXPORT_C TInt CDesC16Array::MdcaCount() const

 /** Returns the number of descriptor elements in the array. The function implements 

 the function interface MDesC16Array::MdcaCount().

 @return The number of descriptor elements. */

     {

     return Count();

     }

 EXPORT_C TPtrC16 CDesC16Array::MdcaPoint(TInt anIndex) const

 /** Indexes into a descriptor array. The function implements the interface MDesC16Array::MdcaPoint().

     @param aIndex The position of the descriptor element within the array. The 

     position is relative to zero; i.e. zero implies the first descriptor element 

     in the array. This value must be non-negative and less than the number of 

     descriptors currently within the array otherwise the operator panics with 

     EArrayIndexOutOfRange. 

     @return A non-modifiable pointer descriptor representing the descriptor element 

     located at position aIndex within the array. */ 

     {

     HBufC16* temp=(*(HBufC16**)At(anIndex));

     return (TPtrC16)(*temp);

     }

 EXPORT_C void CDesC16Array::AppendL(const TDesC16& aPtr)

 /** Appends a descriptor onto the end of any existing descriptor elements in the 

 array.

 @param aPtr A reference to the descriptor to be appended to the array. */

     {

     InsertL(Count(),aPtr);

     }

 EXPORT_C void CDesC16Array::InsertL(TInt aPos,const TDesC16& aPtr)

 /** Inserts a descriptor into the array at the specified position. 

 If the specified position is the same as the current number of descriptor 

 elements in the array, this has the effect of appending the element.

 @param aPos The position within the array where the descriptor element is 

 to be inserted. The position is relative to zero, i.e. zero implies the first 

 descriptor element. This value must not be negative and must not be greater 

 than the number of descriptor elements currently in the array, otherwise the 

 function raises an E32USER-CBase 21 panic. 

 @param aPtr The descriptor to be inserted into the array. */

     {

     HBufC16* bufPtr=aPtr.AllocLC();

     CArrayFixBase::InsertL(aPos,&bufPtr);

     CleanupStack::Pop();

     }

 EXPORT_C TInt CDesC16Array::InsertIsqL(const TDesC16& aPtr,TKeyCmpText aTextComparisonType)

 /** Inserts a descriptor into the array at a position which maintains the sequence 

 of the descriptors.

 The sequence is determined by comparing descriptors using one of the TDesC 

 comparison functions. The enumeration aTextComparisonType governs how the 

 descriptors are to be compared.

 The array should already be in sequence, otherwise the position of the new 

 descriptor element is unpredictable. Descriptor elements which are the same 

 are not permitted.

 @param aPtr A reference to the descriptor to be inserted into the array. 

 @param aTextComparisonType An enumeration which determines the type of comparison 

 to be made between descriptors for the purpose of choosing the insertion position. 

 If no parameter is explicitly passed, ECmpFolded is used by default.

 @return The position within the array of the inserted descriptor. */

     {

     HBufC16* bufPtr=aPtr.AllocLC();

     TKeyDesC16Array key(aTextComparisonType);

     TInt found=CArrayFixBase::InsertIsqL(&bufPtr,key);

     CleanupStack::Pop();

     return(found);

     }

 EXPORT_C TInt CDesC16Array::InsertIsqAllowDuplicatesL(const TDesC16& aPtr,TKeyCmpText aTextComparisonType)

 /** Inserts a descriptor into the array at a position which maintains the sequence 

 of the descriptors; allows duplicates.

 The sequence is determined by comparing descriptors using one of the TDesC 

 comparison functions. The enumeration aTextComparisonType governs how the 

 descriptors are to be compared.

 The array should already be in sequence, otherwise the position of the new 

 descriptor element is unpredictable. Descriptor elements which are the same 

 are permitted; if the descriptor aPtr is a duplicate of an existing descriptor 

 within the array, then the new descriptor element is positioned after the 

 existing descriptor element.

 @param aPtr A reference to the descriptor to be inserted into the array. 

 @param aTextComparisonType An enumeration which determines the type of comparison 

 to be made between descriptors for the purpose of choosing the insertion position. 

 If no parameter is explicitly passed, ECmpFolded is used by default.

 @return The position within the array of the inserted descriptor. */

     {

     HBufC16* bufPtr=aPtr.AllocLC();

     TKeyDesC16Array key(aTextComparisonType);

     TInt found=CArrayFixBase::InsertIsqAllowDuplicatesL(&bufPtr,key);

     CleanupStack::Pop();

     return(found);

     }

 EXPORT_C void CDesC16Array::Sort(TKeyCmpText aTextComparisonType)

 /** Sorts the descriptor elements into sequence.

 The sequence is determined by comparing descriptors using one of the member 

 functions of the descriptor base class TDesC.

 @param aTextComparisonType An enumeration which defines the type of comparison 

 to be made between descriptors. By default the comparison type is ECmpFolded. */

     {

     TKeyDesC16Array key(aTextComparisonType);

     CArrayFixBase::Sort(key);

     }

 EXPORT_C TInt CDesC16Array::Find(const TDesC16& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType) const

 /** Finds the position of a descriptor element within the array which matches the 

 specified descriptor, using a sequential search.

 The array is searched sequentially for a matching descriptor element, starting 

 with the first descriptor element in the array. Descriptors are compared using 

 one of the TDesC comparison functions. The enumeration aTextComparisonType 

 governs how the descriptors are to be compared.

 Where an array has duplicate descriptor elements, the function only supplies 

 the position of the first descriptor element.

 @param aPtr A reference to a descriptor to be used for comparison. 

 @param aPos If the descriptor element is found, this reference is set to the 

 position of that descriptor element within the array. The position is relative 

 to zero, (i.e. the first descriptor element in the array is at position 0). 

 If the descriptor element is not found and the array is not empty, then the 

 value of the reference is set to the number of descriptor elements in the 

 array. If the descriptor element is not found and the array is empty, then 

 the reference is set to zero. 

 @param aTextComparisonType An enumeration which determines the type of comparison 

 to be made between descriptors. If no parameter is explicitly passed,ECmpFolded 

 is used by default. 

 @return Zero, if a matching descriptor element is found. Non-zero, if no matching 

 descriptor element can be found. */

     {

     TKeyDesC16Array key(aTextComparisonType);

     const TDesC16* tmp=(&aPtr);

     return(CArrayFixBase::Find(&tmp,key,aPos));

     }

 EXPORT_C TInt CDesC16Array::FindIsq(const TDesC16& aPtr,TInt& aPos,TKeyCmpText aTextComparisonType) const

 /** Finds the position of a descriptor element within the array which matches the 

 specified descriptor, using a binary search technique. The array must 

 be in sequence, otherwise the outcome is unpredictable.

 Descriptors are compared using one of the TDesC comparison functions. The 

 enumeration aTextComparisonType governs how the descriptors are to be compared.

 Where an array has duplicate descriptor elements, the function cannot guarantee 

 which matching descriptor element it will return; except that it will find 

 one of them.

 @param aPtr A reference to a descriptor to be used for comparison. 

 @param aPos If the descriptor element is found, the reference is set to the 

 position of that descriptor element within the array. The position is relative 

 to zero, (i.e. the first descriptor element in the array is at position 0). 

 If the descriptor element is not found and the array is not empty, then the 

 reference is set to the position of the first descriptor element in the array 

 whose content is greater than the content of aPtr. If the descriptor element 

 is not found and the array is empty, then the reference is set to zero.

 @param aTextComparisonType An enumeration which determines the type of comparison 

 to be made between descriptors. If no parameter is explicitly passed, ECmpFolded 

 is used by default. 

 @return Zero, if a matching descriptor element is found. Non-zero, if no matching 

 descriptor element can be found. */

     {

     TKeyDesC16Array key(aTextComparisonType);

     const TDesC16* tmp=(&aPtr);

     return(CArrayFixBase::FindIsq(&tmp,key,aPos));

     }

 EXPORT_C CDesC16ArraySeg::CDesC16ArraySeg(TInt aGranularity)

     : CDesC16Array((TBufRep)CBufSeg::NewL,aGranularity)

 /** Construct a segmented descriptor array with the specified granularity.

 No memory is allocated to the array buffer by this C++ constructor.

 @param aGranularity The granularity of the array. This value must be positive 

 otherwise the constructor raises an E32USER-CBase 18 panic. */

     {

     __DECLARE_NAME(_S("CDesC16ArraySeg"));

     }

 EXPORT_C CDesC16ArraySeg::~CDesC16ArraySeg()

 /** Frees all resources owned by the object, prior to its destruction. */

     {}

 /* The following 3 function is defined so that the functions IdealLanguage,

 SetIdealLanguage, ReleaseIdealLanguage will compile as part as an .exe

 These functions use a global TAny* to store the data that would have been

 stored in the TLS under normal compilation (ie If the BaUtils was compilled

 as part of a DLL).

 */

 TAny* ptr(NULL);

 TAny* Dll::Tls()

     {

     return ptr;

     }

 TInt Dll::SetTls(TAny* aPtr)

     {

     ptr = aPtr;

     return KErrNone;

     }

 void Dll::FreeTls()

     {

     ptr = NULL;

     }