// 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;
}