// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

 // which accompanies this distribution, and is available

 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #if !defined(__CHARCONV_H__)

 #define __CHARCONV_H__

 #if !defined(__E32STD_H__)

 #include <e32std.h>

 #endif

 #if !defined(__E32BASE_H__)

 #include <e32base.h>

 #endif

 /** 

 The maximum length in bytes of the replacement text for unconvertible Unicode 

 characters (=50) (see CCnvCharacterSetConverter::SetReplacementForUnconvertibleUnicodeCharactersL()). 

 @publishedAll

 @released

 */

 const TInt KMaximumLengthOfReplacementForUnconvertibleUnicodeCharacters=50;

 /** 

 UTF-7 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierUtf7=0x1000582c;

 /** 

 UTF-8 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierUtf8=0x1000582d;

 /** 

 IMAP UTF-7 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierImapUtf7=0x1000582e;

 /** 

 Java UTF-8 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierJavaConformantUtf8=0x1000582f;

 /** 

 Code Page 1252 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierCodePage1252=0x100012b6;

 /** 

 ISO 8859-1 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88591=0x10003b10;

 /** 

 ISO 8859-2 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88592=0x1000507e;

 /** 

 ISO 8859-3 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88593=0x10008a28;

 /** 

 ISO 8859-4 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88594=0x1000507f;

 /** 

 ISO 8859-5 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88595=0x10005080;

 /** 

 ISO 8859-6 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88596=0x10008a29;

 /** 

 ISO 8859-7 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88597=0x10005081;

 /** 

 ISO 8859-8 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88598=0x10008a2a;

 /** 

 ISO 8859-9 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso88599=0x10005082;

 /** 

 ISO 8859-10 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso885910=0x10008a2b;

 /** 

 ISO 8859-13 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso885913=0x10008a2c;

 /** 

 ISO 8859-14 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso885914=0x10008a2d;

 /** 

 ISO 8859-15 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso885915=0x10008a2e;

 /** 

 ASCII 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierAscii=0x10004cc6;

 /** 

 SMS 7-bit 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierSms7Bit=0x100053ab;

 /** 

 GB 2312 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierGb2312=0x10000fbe;

 /** 

 HZ-GB-2312 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierHz=0x10006065;

 /** 

 GB 12345 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierGb12345=0x1000401a;

 /** 

 GBK 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierGbk=0x10003ecb;

 /** 

 Big 5 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierBig5=0x10000fbf;

 /** 

 Shift-JIS 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierShiftJis=0x10000fbd;

 /** 

 ISO-2022-JP 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso2022Jp=0x100066a0;

 /** 

 ISO-2022-JP-1 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierIso2022Jp1=0x100066a3;

 /** 

 JIS Encoding 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierJis=0x10006066;

 /** 

 EUC-JP 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierEucJpPacked=0x10006067;

 /** 

 JP5 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierJ5=0x1020D408;

 /** 

 CP850 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierCP850=0x102825AD;

 const TUint KCharacterSetIdentifierUnicodeLittle=0x101f3fae;  //Little Endian Unicode

 const TUint KCharacterSetIdentifierUnicodeBig=0x101f4052; // Big Endian Unicode 

 const TUint KCharacterSetIdentifierUcs2=0x101ff492;

 /** 

 Extended SMS 7-bit (not supported before v9.5) 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierExtendedSms7Bit=0x102863FD;

 /** 

 Turkish 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierTurkishSingleSms7Bit=0x102863FE;

 const TUint KCharacterSetIdentifierTurkishLockingSms7Bit=0x102863FF;

 const TUint KCharacterSetIdentifierTurkishLockingAndSingleSms7Bit=0x10286400;

 /** 

 Portuguese 

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierPortugueseSingleSms7Bit=0x10286407;

 const TUint KCharacterSetIdentifierPortugueseLockingSms7Bit=0x10286408;

 const TUint KCharacterSetIdentifierPortugueseLockingAndSingleSms7Bit=0x10286409;

 /** 

 Spanish

 @publishedAll

 @released

 */

 const TUint KCharacterSetIdentifierSpanishSingleSms7Bit=0x1028640A;

 // note that other character sets than those listed above may be available at run-time, and also that none of the above are necessarily available at run-time

 struct SCnvConversionData;

 class CDeepDestructingArrayOfCharactersSets;

 class CFileReader;

 class CStandardNamesAndMibEnums;

 class RFs;

 class CCharsetCnvCache;

 /** 

 Converts text between Unicode and other character sets. 

 The first stage of the conversion is to specify the non-Unicode character 

 set being converted to or from. This is done by calling one of the overloads 

 of PrepareToConvertToOrFromL().

 The second stage is to convert the text, using one of the overloads of 

 ConvertFromUnicode() or ConvertToUnicode().

 Where possible the first documented overload of PrepareToConvertToOrFromL() 

 should be used because the second overload panics if the specified character 

 set is not available: the first overload simply returns whether the character 

 set is available or not available. However if the conversions are to be 

 performed often, or if the user must select the character set for the 

 conversion from a list, the second overload may be more appropriate.

 The first overload is less efficient than the second, because it searches 

 through the file system for the selected character set every time it is invoked. 

 The second overload searches through an array of all available character sets. 

 In this method, the file system need only be searched once - when 

 CreateArrayOfCharacterSetsAvailableLC() or 

 CreateArrayOfCharacterSetsAvailableL() is used to create the array.

 The conversion functions allow users of this class to perform partial 

 conversions on an input descriptor, handling the situation where the input 

 descriptor is truncated mid way through a multi-byte character. This means 

 that you do not have to guess how big to make the output descriptor for a 

 given input descriptor, you can simply do the conversion in a loop using a 

 small output descriptor. The ability to handle truncated descriptors also 

 allows users of the class to convert information received in chunks from an 

 external source.

 The class also provides a number of utility functions. 

 @publishedAll

 @released

 */

 class CCnvCharacterSetConverter : public CBase

 	{

 public:

 	/** Indicates whether a character set is available or unavailable 

 	for conversion. Used by the second overload of 

 	PrepareToConvertToOrFromL(). */

 	enum TAvailability

 		{

 		/** The requested character set can be converted. */

 		EAvailable,

 		/** The requested character set cannot be converted. */

 		ENotAvailable

 		};

 	/** Conversion error flags. At this stage there is only one error 

 	flag- others may be added in the future. */

 	enum TError

 		{

 		/** The input descriptor contains a single corrupt character. This 

 		might occur when the input descriptor only contains some of the bytes 

 		of a single multi-byte character. */

 		EErrorIllFormedInput=KErrCorrupt

 		};

 	/** Specifies the default endian-ness of the current character set. 

 	Used by SetDefaultEndiannessOfForeignCharacters(). */

 	enum TEndianness

 		{

 		/** The character set is big-endian. */

 		ELittleEndian,

 		/** The character set is little-endian. */

 		EBigEndian

 		};

 	/** Downgrade for line and paragraph separators */

 	enum TDowngradeForExoticLineTerminatingCharacters

 		{

 		/** Paragraph/line separators should be downgraded (if necessary) 

 		into carriage return and line feed pairs. */

 		EDowngradeExoticLineTerminatingCharactersToCarriageReturnLineFeed,

 		/** Paragraph/line separators should be downgraded (if necessary) 

 		into a line feed only. */

 		EDowngradeExoticLineTerminatingCharactersToJustLineFeed

 		};

 	/** Output flag used to indicate whether or not a character in the source

 	descriptor is the first half of a surrogate pair, but is the last

 	character in the descriptor to convert.

 	Note: This enumeration can be used in the DoConvertToUnicode() and

 	DoConvertFromUnicode() functions. These are part of the

 	Character Conversion Plug-in Provider API and are for use by plug-in

 	conversion libraries only.

 	@since 6.0 */

 	enum

 		{

 		/** Appends the converted text to the output descriptor.*/

 		EInputConversionFlagAppend	=0x00010000,

 		/** By default, when the input descriptor passed to DoConvertFromUnicode()

 		or DoConvertToUnicode() consists of nothing but a truncated sequence, 

 		the error-code EErrorIllFormedInput is returned. 

 		If this behaviour is undesirable, the input flag  

 		EInputConversionFlagAllowTruncatedInputNotEvenPartlyConsumable

 		should be set. */

 		EInputConversionFlagAllowTruncatedInputNotEvenPartlyConsumable	=0x00020000,

 		/** Stops converting when the first unconvertible character is reached. */

 		EInputConversionFlagStopAtFirstUnconvertibleCharacter			=0x00040000,

 		/** Appends the default character set Escape sequence at end of converted text */

 		EInputConversionFlagMustEndInDefaultCharacterSet				=0x00080000,

 		/*defect fix: INC053609; According to RFC1468 we can assume the line starts 

 		in ASCII so there is no need to always insert an escape sequence*/

 		EInputConversionFlagAssumeStartInDefaultCharacterSet			=0x00100000

 		};

 	enum

 		{

 		/** Indicates whether or not the source descriptor ends in a truncated

 		sequence, e.g. the first half only of a surrogate pair. */

 		EOutputConversionFlagInputIsTruncated							=0x01000000

 		};

 		/** Initial value for the state argument in a set of related calls to

 		ConvertToUnicode(). */

 	enum {KStateDefault=0};

 	enum 

 		{

 		/** The lowest confidence value for a character set accepted by 

 		Autodetect*/

 		ELowestThreshold = 25

 		};

 	/** Stores information about a non-Unicode character set. The information 

 	is used	to locate the conversion information required by 

 	ConvertFromUnicode() and ConvertToUnicode().

 	An array of these structs that contain all available character sets 

 	can be generated by CreateArrayOfCharacterSetsAvailableLC() and 

 	CreateArrayOfCharacterSetsAvailableL(), and is used by one of the 

 	overloads of PrepareToConvertToOrFromL(). */

 	struct SCharacterSet

 		{

 		/** Gets the character sets UID.

 		@return The UID of the character set. */

 		inline TUint Identifier() const {return iIdentifier;}

 		/** Tests whether a filename given by the function SCharacterSet::Name() 

 		is a real file name (i.e. conversion is provided by a plug in DLL), or 

 		just the character set name (i.e. conversion is built into Symbian OS).

 		Note: If the function returns ETrue then the path and filename can be 

 		parsed using TParse or TParsePtrC functions to obtain just the filename.

 		@return ETrue if the name is a real filename. EFalse if it is just the 

 		character set name. */

 		inline TBool NameIsFileName() const {return iFlags&EFlagNameIsFileName;}

 		/** Gets the full path and filename of the DLL which implements 

 		conversion for the character set. 

 		If the character set is one for which conversion is built into Symbian 

 		OS rather than implemented by a plug in DLL, the function just returns 

 		the name of the character set. The NameIsFileName() function can be 

 		used to determine whether or not it is legal to create a TParsePtrC 

 		object over the descriptor 	returned by Name().

 		Notes:

 		The name returned cannot be treated as an Internet-standard name, it 

 		is locale-independent and should be mapped to the locale-dependent name 

 		by software at a higher level before being shown to the user. Conversion 

 		from Internet-standard names of character sets to the UID identifiers 

 		is provided by the member function 

 		ConvertStandardNameOfCharacterSetToIdentifierL().

 		Typically, to find the user-displayable name (as opposed to the 

 		internet-standard name) of a character set, you would do something 

 		like this:

 		@code

 		const CCnvCharacterSetConverter::SCharacterSet& characterSet=...;

 		const TPtrC userDisplayable(characterSet.NameIsFileName()? TParsePtrC(characterSet.Name()).Name(): 

 		characterSet.Name()); 

 		@endcode

 		@return Full path and filename of the character set converter plug in 

 		DLL, or just the name of the character set. */

 		inline TPtrC Name() const {return *iName;}

 	private:

 		enum

 			{

 			EFlagNameIsFileName					=0x00000001,

 			EFlagFileIsConversionPlugInLibrary	=0x00000002

 			};

 	private:

 		inline TBool FileIsConversionPlugInLibrary() const {return iFlags&EFlagFileIsConversionPlugInLibrary;}

 	private:

 		TUint iIdentifier;

 		TUint iFlags;

 		HBufC* iName;

 	private:

 		friend class CCnvCharacterSetConverter;

 		friend class CDeepDestructingArrayOfCharactersSets;

 		}; //SCharacterSet

 	/** 

 	Holds an ascending array of the indices of the characters in the 

 	source Unicode text which could not be converted by 

 	CCnvCharacterSetConverter::ConvertFromUnicode() into the foreign 

 	character set 

 	@publishedAll

 	@released

 	*/

 	class TArrayOfAscendingIndices

 		{

 	public:

 		/** The return value of CCnvCharacterSetConverter::AppendIndex(). */

 		enum TAppendResult

 			{

 			/** The append failed. */

 			EAppendFailed,

 			/** The append succeeded. */

 			EAppendSuccessful

 			};

 	public:

 		/** C++ constructor. The array is initialised to be of length zero. */

 		inline TArrayOfAscendingIndices() :iArrayOfIndices(0) {}

 		IMPORT_C TAppendResult AppendIndex(TInt aIndex);

 		/** Deletes a single index from the array.

 		@param aIndexOfIndex The index of the index to delete. Must not be 

 		negative and must not be greater than the length of the array, or a 

 		panic occurs. */

 		inline void Remove(TInt aIndexOfIndex) {iArrayOfIndices.Delete(aIndexOfIndex, 1);}

 		/** Deletes all indices from the array. */

 		inline void RemoveAll() {iArrayOfIndices.SetLength(0);}

 		/** Returns the number of indices in the array.

 		@return The number of indices in the array. */

 		inline TInt NumberOfIndices() const {return iArrayOfIndices.Length();}

 		/** Gets the value of the specified index.

 		@param aIndexOfIndex Index into the array.

 		@return The value of the index. */

 		inline TInt operator[](TInt aIndexOfIndex) const {return iArrayOfIndices[aIndexOfIndex];}

 	private:

 		enum {KMaximumNumberOfIndices=25};

 	private:

 		TBuf16<KMaximumNumberOfIndices> iArrayOfIndices;

 		};

 public:

 	IMPORT_C static CCnvCharacterSetConverter* NewL();

 	IMPORT_C static CCnvCharacterSetConverter* NewLC();

 	IMPORT_C virtual ~CCnvCharacterSetConverter();

 	IMPORT_C static CArrayFix<SCharacterSet>* CreateArrayOfCharacterSetsAvailableL(RFs& aFileServerSession);

 	IMPORT_C static CArrayFix<SCharacterSet>* CreateArrayOfCharacterSetsAvailableLC(RFs& aFileServerSession);

 	IMPORT_C TUint ConvertStandardNameOfCharacterSetToIdentifierL(const TDesC8& aStandardNameOfCharacterSet, RFs& aFileServerSession);

 	IMPORT_C HBufC8* ConvertCharacterSetIdentifierToStandardNameL(TUint aCharacterSetIdentifier, RFs& aFileServerSession);

 	IMPORT_C TUint ConvertMibEnumOfCharacterSetToIdentifierL(TInt aMibEnumOfCharacterSet, RFs& aFileServerSession);

 	IMPORT_C TInt ConvertCharacterSetIdentifierToMibEnumL(TUint aCharacterSetIdentifier, RFs& aFileServerSession);

 	IMPORT_C void PrepareToConvertToOrFromL(TUint aCharacterSetIdentifier, const CArrayFix<SCharacterSet>& aArrayOfCharacterSetsAvailable, RFs& aFileServerSession);

 	IMPORT_C TAvailability PrepareToConvertToOrFromL(TUint aCharacterSetIdentifier, RFs& aFileServerSession);

 	// the following attribute-setting functions should be called (if at all) after calling PrepareToConvertToOrFromL and before calling ConvertFromUnicode and/or ConvertToUnicode

 	IMPORT_C void SetDefaultEndiannessOfForeignCharacters(TEndianness aEndianness);

 	IMPORT_C void SetDowngradeForExoticLineTerminatingCharacters(TDowngradeForExoticLineTerminatingCharacters aDowngradeForExoticLineTerminatingCharacters); // by default this attribute is set to EDowngradeExoticLineTerminatingCharactersToCarriageReturnLineFeed

 	IMPORT_C void SetReplacementForUnconvertibleUnicodeCharactersL(const TDesC8& aReplacementForUnconvertibleUnicodeCharacters); // must be a single character preceded by its escape sequence (if any), and must be little-endian if the endianness of the character-set is unspecified, otherwise in the same endianness as the character-set

 	// the conversion functions return either one of the TError values above, or the number of unconverted elements left at the end of the input descriptor

 	IMPORT_C TInt ConvertFromUnicode(TDes8& aForeign, const TDesC16& aUnicode) const;

 	IMPORT_C TInt ConvertFromUnicode(TDes8& aForeign, const TDesC16& aUnicode, TInt& aNumberOfUnconvertibleCharacters) const;

 	IMPORT_C TInt ConvertFromUnicode(TDes8& aForeign, const TDesC16& aUnicode, TInt& aNumberOfUnconvertibleCharacters, TInt& aIndexOfFirstUnconvertibleCharacter) const;

 	IMPORT_C TInt ConvertFromUnicode(TDes8& aForeign, const TDesC16& aUnicode, TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters) const;

 	IMPORT_C TInt ConvertToUnicode(TDes16& aUnicode, const TDesC8& aForeign, TInt& aState) const;

 	IMPORT_C TInt ConvertToUnicode(TDes16& aUnicode, const TDesC8& aForeign, TInt& aState, TInt& aNumberOfUnconvertibleCharacters) const;

 	IMPORT_C TInt ConvertToUnicode(TDes16& aUnicode, const TDesC8& aForeign, TInt& aState, TInt& aNumberOfUnconvertibleCharacters, TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter) const;

 	IMPORT_C static void AutoDetectCharacterSetL(TInt& aConfidenceLevel, TUint& aCharacterSetIdentifier, const CArrayFix<SCharacterSet>& aArrayOfCharacterSetsAvailable, const TDesC8& aSample);

 	IMPORT_C void AutoDetectCharSetL(TInt& aConfidenceLevel, TUint& aCharacterSetIdentifier, const CArrayFix<SCharacterSet>& aArrayOfCharacterSetsAvailable, const TDesC8& aSample);

 	IMPORT_C static void ConvertibleToCharacterSetL(TInt& aConfidenceLevel, const TUint aCharacterSetIdentifier,const CArrayFix<SCharacterSet>& aArrayOfCharacterSetsAvailable, const TDesC8& aSample);

     IMPORT_C void ConvertibleToCharSetL(TInt& aConfidenceLevel, const TUint aCharacterSetIdentifier,const CArrayFix<SCharacterSet>& aArrayOfCharacterSetsAvailable, const TDesC8& aSample);

 	IMPORT_C void SetMaxCacheSize(TInt aSize);

 	// the following functions are only to be called by conversion plug-in libraries

 	IMPORT_C static TInt DoConvertFromUnicode(const SCnvConversionData& aConversionData, TEndianness aDefaultEndiannessOfForeignCharacters, const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, TDes8& aForeign, const TDesC16& aUnicode, TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters);

 	IMPORT_C static TInt DoConvertFromUnicode(const SCnvConversionData& aConversionData, TEndianness aDefaultEndiannessOfForeignCharacters, const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, TDes8& aForeign, const TDesC16& aUnicode, TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters, TUint& aOutputConversionFlags, TUint aInputConversionFlags);

 	IMPORT_C static TInt DoConvertToUnicode(const SCnvConversionData& aConversionData, TEndianness aDefaultEndiannessOfForeignCharacters, TDes16& aUnicode, const TDesC8& aForeign, TInt& aNumberOfUnconvertibleCharacters, TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter);

 	IMPORT_C static TInt DoConvertToUnicode(const SCnvConversionData& aConversionData, TEndianness aDefaultEndiannessOfForeignCharacters, TDes16& aUnicode, const TDesC8& aForeign, TInt& aNumberOfUnconvertibleCharacters, TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter, TUint& aOutputConversionFlags, TUint aInputConversionFlags);

 	IMPORT_C static const SCnvConversionData& AsciiConversionData();

 	inline TDowngradeForExoticLineTerminatingCharacters GetDowngradeForExoticLineTerminatingCharacters () 

 		{

 		return iDowngradeForExoticLineTerminatingCharacters ;

 		} ; 

 private:

 	enum

 		{

 		EStoredFlagOwnsConversionData				=0x00000001,

 		EStoredFlagConversionPlugInLibraryIsLoaded	=0x00000002

 		};

 	enum TCharacterSetSearch

 		{

 		EStopCharacterSetSearch,

 		EContinueCharacterSetSearch

 		};

 	enum TConversionPlugInFunctionOrdinals

 		{

 		EReplacementForUnconvertibleUnicodeCharacters=1,

 		EConvertFromUnicode=2,

 		EConvertToUnicode=3,

 		EIsInThisCharacterSet=4

 		};

 private:

 	CCnvCharacterSetConverter();

 	void ConstructL();

 	static CArrayFix<SCharacterSet>* DoCreateArrayOfCharacterSetsAvailableLC(RFs& aFileServerSession, TUint aIdentifierOfOnlyCharacterSetOfInterest);

 	static TCharacterSetSearch AppendHardCodedCharacterSetIfRequiredL(CArrayFix<SCharacterSet>& aArrayOfCharacterSets, TUint aIdentifierOfOnlyCharacterSetOfInterest, TUint aIdentifierOfHardCodedCharacterSet, const TDesC& aNameOfHardCodedCharacterSet);

 	void ScanForStandardNamesAndMibEnumsL(RFs& aFileServerSession);

 	void ScanForStandardNamesAndMibEnumsROMOnlyL(RFs& aFileServerSession);

 	TAvailability DoPrepareToConvertToOrFromL(TUint aCharacterSetIdentifier, const CArrayFix<SCharacterSet>* aArrayOfCharacterSetsAvailable, RFs& aFileServerSession);

 	static void DeleteConversionData(const SCnvConversionData* aConversionData);

 	static void DeleteConversionData(TAny* aConversionData);

 	static TEndianness EndiannessOfForeignCharacters(const SCnvConversionData& aConversionData, TEndianness aDefaultEndiannessOfForeignCharacters);

 private:

 	TUint iStoredFlags;

 	TUint iCharacterSetIdentifierOfLoadedConversionData; // 0 or a UID of the loaded plugin

 	const SCnvConversionData* iConversionData;

 	TEndianness iDefaultEndiannessOfForeignCharacters;

 	TDowngradeForExoticLineTerminatingCharacters iDowngradeForExoticLineTerminatingCharacters;

 	TBuf8<KMaximumLengthOfReplacementForUnconvertibleUnicodeCharacters> iReplacementForUnconvertibleUnicodeCharacters;

 	CStandardNamesAndMibEnums* iStandardNamesAndMibEnums;

 	TBool iFullyConstructed;

 	CCharsetCnvCache* iCharsetCnvCache;

 	TBool iIsSystemStandardNamesAndMibEnumsScanned;

 	};

 #endif