/*

 * Copyright (c) 2005-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 <e32std.h>

 #include <charconv.h>

 #include <convgeneratedcpp.h>

 #include "ucs2.h"

 #include <ecom/implementationproxy.h>

 #include <charactersetconverter.h>

 class CUCS2ConverterImpl : public CCharacterSetConverterPluginInterface

 	{

 public:

 	virtual const TDesC8& ReplacementForUnconvertibleUnicodeCharacters();

 	virtual TInt ConvertFromUnicode(

 		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

 		const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 

 		TDes8& aForeign, 

 		const TDesC16& aUnicode, 

 		CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters);

 	virtual TInt ConvertToUnicode(

 		CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

 		TDes16& aUnicode, 

 		const TDesC8& aForeign, 

 		TInt& aState, 

 		TInt& aNumberOfUnconvertibleCharacters, 

 		TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter);

 	virtual TBool IsInThisCharacterSetL(

 		TBool& aSetToTrue, 

 		TInt& aConfidenceLevel, 

 		const TDesC8& aSample);

 	static CUCS2ConverterImpl* NewL();

 	virtual ~CUCS2ConverterImpl();

 private:

 	CUCS2ConverterImpl();

 	};

 // The following code has been copied and modified from the plugin computer generated code

 // that is generated from the charconv/data/???.cpl && /???.txt files

 // *** code begins ***

 #define ARRAY_LENGTH(aArray) (sizeof(aArray)/sizeof((aArray)[0]))

 #pragma warning (disable: 4049) // compiler limit : terminating line number emission

 _LIT8(KLit8ReplacementForUnconvertibleUnicodeCharacters, "\xff\xfd");

 GLDEF_C const TDesC8& ReplacementForUnconvertibleUnicodeCharacters_internal()

 	{

 	return KLit8ReplacementForUnconvertibleUnicodeCharacters;

 	}

 GLDEF_D const SCnvConversionData conversionData=

 	{

 	SCnvConversionData::EUnspecified,

 	{NULL,NULL},

 	{NULL,NULL},

 	{NULL,NULL},

 	NULL,

 	NULL

 	};

 const TInt    KByteOrderMark = 0xfeff;

 const TInt 	  KStateOffset = 0x1000;

 const TDesC8& CUCS2ConverterImpl::ReplacementForUnconvertibleUnicodeCharacters()

 	{

 	return ReplacementForUnconvertibleUnicodeCharacters_internal();

 	}

 /**

  * Takes a 16 bit UCS2 descriptor with or without BOM and translates it to an

  * eight bit descriptor in Big Endian format.

  *

  * Note aDefaultEndiannessOfForeignCharacters is not used by this converter

  *

  * @param CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters

  * @param const TDesC8&

  * @param TDes8& aForeign

  * @param const TDesC16& aUnicode

  * @param CCnvCharacterSetConverter::TArrayOfAscendingIndices&

  *

  * returns number of converted characters

 */

 TInt CUCS2ConverterImpl::ConvertFromUnicode(CCnvCharacterSetConverter::TEndianness /*aDefaultEndiannessOfForeignCharacters*/, 

 								 const TDesC8& /*aReplacementForUnconvertibleUnicodeCharacters*/, 

 								 TDes8& aForeign, 

 								 const TDesC16& aUnicode, 

 								 CCnvCharacterSetConverter::TArrayOfAscendingIndices& /*aIndicesOfUnconvertibleCharacters*/)

 	{

 	TInt numberOfUnicodeCharacters =0;

 	TInt nextChar;

 	// start at the begining of the output buffer

 	aForeign.Zero();

 	// while there is unicode data to convert and space in the output buffer

 	while ( (aForeign.Length() + 1 < aForeign.MaxLength()) && (numberOfUnicodeCharacters < aUnicode.Length()) )

 		{

 		nextChar = aUnicode[numberOfUnicodeCharacters];

 		// Note - this always converts to EBigEndian 

 		aForeign.Append((nextChar & 0xff00) >> 8);

 		aForeign.Append(nextChar & 0xff );

 		numberOfUnicodeCharacters++;

 		}

 	// returns the number of unconverted characters left at the end of the input descriptor  

 	return aUnicode.Length() - numberOfUnicodeCharacters;

 	}

 /**

  * Takes an 8 bit descriptor with or without a BOM and translates it to unicode 

  * Input endiness is determined by Byte Order Markers (BOM) in the source text.

  * If no BOM is present aDefaultEndiannessOfForeignCharacters is used.

  *

  * When the data is too large to fit in the output buffer, the endiness is saved in the state

  * variable between conversions

  *

  * @param aDefaultEndiannessOfForeignCharacters Default endiness if no BOMs present in the source

  * @param aUnicode Contains the converted text in the Unicode character set

  * @param aForeign The non-Unicode source text to be converted

  * @param aState Not used by this converter

  * @param aNumberOfUnconvertibleCharacters Contains the number of bytes which could not be converted to unicode

  * @param aIndexOfFirstByteOfFirstUnconvertibleCharacter The index of the first unconvertable byte or -1 if all converted.

  *

  * @return aNumberOfUnconvertibleCharacters The number of unconverted bytes left at the end of the input 

  * descriptor (e.g. because the output descriptor is not long enough to hold all the text), or one of the 

  * error values defined in TError. 

  * @internalTechnology 

  */

 TInt CUCS2ConverterImpl::ConvertToUnicode(CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, 

 						   TDes16& aUnicode,	

 						   const TDesC8& aForeign,

 						   TInt& aState,

 						   TInt& aNumberOfUnconvertibleCharacters, 

 						   TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter) 

 	{

 	TInt numberOfBytesConverted = 0;

 	TInt numberOfUnicodeCharacters =0;

 	TChar nextChar;

 	// work out what byte order to use

 	CCnvCharacterSetConverter::TEndianness byteOrderMark;

 	if ( aState==CCnvCharacterSetConverter::KStateDefault )

 		{

 		// this is the first call so use the default or BOM for byte order

 		byteOrderMark = aDefaultEndiannessOfForeignCharacters;

 		}

 	else

 		{

 		// this is not the first call so use the saved byte order

 		byteOrderMark = STATIC_CAST( CCnvCharacterSetConverter::TEndianness, aState - KStateOffset );

 		}

 	if ( aForeign.Length() < 2)

 		{ // too small to do anything with		

 		return -1;

 		}

 	// If the state is KStateDefault (this is the first call) check for BOM markers

 	else if (aState==CCnvCharacterSetConverter::KStateDefault)

 		{

 		// is there a Little Endian BOM

 		if (aForeign[0]==0xff && aForeign[1]==0xfe )

 			{ 

 			byteOrderMark = CCnvCharacterSetConverter::ELittleEndian; 

 			}

 		else if (aForeign[0]==0xfe && aForeign[1]==0xff )

 			{

 			byteOrderMark = CCnvCharacterSetConverter::EBigEndian; 

 			}

 		// remember the detected state

 		aState = byteOrderMark + KStateOffset;

 		}

 	// start at begining of the output buffer provided

 	aUnicode.Zero();

 	// while there is at least 2 bytes of data to convert and space in the output buffer

 	while ( (numberOfBytesConverted+1 < aForeign.Size()) && (numberOfUnicodeCharacters < aUnicode.MaxLength()) )

 		{

 		if (byteOrderMark == CCnvCharacterSetConverter::ELittleEndian )

 			{

 			// ELittleEndian 0x??00

 			nextChar = aForeign[numberOfBytesConverted] + ( aForeign[numberOfBytesConverted+1] << 8);

 			}

 		else

 			{

 			// EBigEndian 0x00??

 			nextChar = ( aForeign[numberOfBytesConverted] <<8 ) + aForeign[numberOfBytesConverted+1];

 			}

 		// save the unicode character extracted	unless it's a BOM

 		if ( nextChar != KByteOrderMark )

 			{

 			aUnicode.Append( nextChar );

 			numberOfUnicodeCharacters++;	

 			}

 		numberOfBytesConverted+=2;

 		}

 	// there are no uncovertable characters with UCS2,

 	aNumberOfUnconvertibleCharacters = 0;

 	// a negative value indicates that all characters converted

 	aIndexOfFirstByteOfFirstUnconvertibleCharacter = -1;

 	// returns the number of unconverted bytes left at the end of the input descriptor 

 	// Note there could be 1 byte left over if an odd number of bytes provided for conversion

 	return aForeign.Size() - numberOfBytesConverted;

 	}

 /**

  * This converter does not support autodetect so always returns a confidence value of 0.

  * @internalTechnology 

  */

 TBool CUCS2ConverterImpl::IsInThisCharacterSetL(TBool& aSetToTrue, TInt& aConfidenceLevel, const TDesC8&)

 	{

 	aSetToTrue=ETrue;

 	aConfidenceLevel=0;

 	return EFalse;

 	}

 CUCS2ConverterImpl* CUCS2ConverterImpl::NewL()

 	{

 	CUCS2ConverterImpl* self = new(ELeave) CUCS2ConverterImpl();

 	return self;

 	}

 CUCS2ConverterImpl::~CUCS2ConverterImpl()

 	{

 	}

 CUCS2ConverterImpl::CUCS2ConverterImpl()

 	{

 	}

 const TImplementationProxy ImplementationTable[] = 

 	{

 		IMPLEMENTATION_PROXY_ENTRY(0x101FF492,	CUCS2ConverterImpl::NewL)

 	};

 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

 	{

 	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

 	return ImplementationTable;

 	}