// 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:
// This file contains declarations of string methods used by
// XmlEngine's modules.
//

#include <xml/utils/xmlengxestrings.h>
#include <xml/utils/xmlengmem.h>
#include <xml/utils/xmlengutils.h>

#include <stdapis/libxml2/libxml2_xmlstring.h>
#include <stdapis/libxml2/libxml2_globals.h>

#include <utf.h>
#include <escapeutils.h>

//----------------------------------------------------------- TXmlEngConstString

// ------------------------------------------------------------------------------
// Compares two strings.
//
// @return Result as <b>strcmp()</b>
// ------------------------------------------------------------------------------
//
EXPORT_C TBool TXmlEngConstString::Compare(
    TXmlEngConstString aString ) const
    {
    char* str2 = aString.iString;
    char* str1 = iString;
    if (str1 == str2)
        {
        return(0);
        }
    if (!str1 && *str2 == '\x0')
        {
        return(0);
        }
    if (!str2 && *str1 == '\x0')
        {
        return(0);
        }
    if (!str1 )
        {
        return(-1);
        }
    if (!str2 )
        {
        return(1);
        }

    register int tmp;
    do  {
        tmp = *str1++ - *str2;
        if (tmp != 0) 
            return(tmp);
        } while (*str2++ != 0);
    return 0;
    }

// ------------------------------------------------------------------------------
// Returns copy of the TXmlEngConstString contents
// ------------------------------------------------------------------------------
//
EXPORT_C char* TXmlEngConstString::CopyL() const
    {

    xmlChar* copy = xmlStrdup((xmlChar*)iString);
    OOM_IF(iString && !copy);

    return (char*) copy;
    }


// ------------------------------------------------------------------------------
// Returns size of string in bytes
// ------------------------------------------------------------------------------
//
EXPORT_C TUint TXmlEngConstString::Size() const 
    {
	if (iString)
		{
		return (TUint)strlen(iString);
		}
    return 0;
    }

// ------------------------------------------------------------------------------
// @return Size of a string: a number of characters
// @note for non-ASCII contents <b>Size() != Length()</b>
// ------------------------------------------------------------------------------
//
EXPORT_C TUint TXmlEngConstString::Length()  const
    {
    // Note: return 0 for NULL strings
    if(!iString)
        return 0;
    TInt len = xmlUTF8Strlen((const xmlChar*)iString);
    return len != -1 ? (TUint)len : 0;
    }

//---------------------------------------------------------------------- TXmlEngString

// ------------------------------------------------------------------------------
// Frees the string
// ------------------------------------------------------------------------------
//
EXPORT_C void TXmlEngString::Free()
    {xmlFree(iString); iString = 0;}

// ------------------------------------------------------------------------------
// Transfers string and its ownership between TXmlEngString objects;
//
// Any previous content is freed. The source becomes empty (NULL).
// This allows reusing TXmlEngString variables and free them only once.
//
// @note
// This is only a convenience method: it allows avoiding many TXmlEngString variables
// and corresponding calls of Free() method for each. In practice, having a separate
// variable for string values makes code more clearer [No performance impact too].
// ------------------------------------------------------------------------------
//
EXPORT_C void TXmlEngString::Set(TXmlEngString& aSrc)
    {
    if(iString)
        {
        if(iString == aSrc.iString)
            {
            return;
            }
        else
            {
            delete iString;
            }
        }
    iString = aSrc.iString;
    aSrc.iString = 0;
    }

inline HBufC* HBufCFromXmlCharLC(
    const void* aUtf8String )
    {
    if (!aUtf8String)
        return KNullDesC().AllocLC();

    HBufC* res = CnvUtfConverter::ConvertToUnicodeFromUtf8L(
                        TPtrC8((TUint8*)aUtf8String,
                        strlen((char*)aUtf8String)));		
    CleanupStack::PushL(res);
    return res;
    }

inline HBufC* HBufCFromXmlCharL(
    const void* aUtf8String ) 
    {
    if(!aUtf8String)
        return KNullDesC().AllocL();
    else
        return CnvUtfConverter::ConvertToUnicodeFromUtf8L(
                    TPtrC8((TUint8*)aUtf8String,
                    strlen((char*)aUtf8String)));
    }

/**
Allocates UTF-16 heap descriptor from the TDOMString contents

Typical use:
@code
    ...
    HBufC* attrValue = attr.Value().AllocL();
    ...
@endcode

AllocLC() does the same, but returned HBufC* is already on the cleanup stack
after a call to this method.
*/
EXPORT_C HBufC* TXmlEngConstString::AllocL(void) const
    {
    return HBufCFromXmlCharL(iString); // Note: it's inlined
    }

/**
Allocates UTF-16 heap descriptor from the TXmlEngConstString contents and
pushes the descriptor to cleanup stack.

Typical use:
@code
    ...
    HBufC* attrValue = attr.Value().AllocLC();
    ...
@endcode
*/
EXPORT_C HBufC* TXmlEngConstString::AllocLC(void)const
    {
    return HBufCFromXmlCharLC(iString);  // Note: it's inlined
    }

// ------------------------------------------------------------------------------
// Initialize TDOMString from Symbian descriptor.
//
// UTF-16 content of descriptor is converted into UTF-8 zero-terminated
// c-string, for which memory is allocated.
// ------------------------------------------------------------------------------
//
EXPORT_C void TXmlEngString::SetL(const TDesC& aDes)
    {
    if(iString)
        PushL();
    char* str = const_cast<char*> (XmlEngXmlCharFromDesL(aDes));
    if (iString)    
        CleanupStack::PopAndDestroy(iString);
    iString = str;
    }

//
// ------------------------------------------------------------------------------
// Initialize TDOMString from Symbian descriptor.
//
// Byte content of descriptor is taken as UTF-8 string,
// and zero-terminated c-string is created from it.
// ------------------------------------------------------------------------------
//
EXPORT_C void TXmlEngString::SetL(const TDesC8& aDes8)
    {
    if(iString)
        PushL();
    char* str = const_cast<char*> (XmlEngXmlCharFromDes8L(aDes8));
    if (iString)    
        CleanupStack::PopAndDestroy(iString);
    iString = str;
    }

// ------------------------------------------------------------------------------
// Allocates heap descriptor as AllocL() and frees internal c-string.
//
// Typical use:
// @code
//    ...
//    HBufC* attrValue = attr.WholeValueCopyL().AllocAndFreeL();
//    ...
// @endcode
//
// AllocAndFreeLC() does the same, but returned HBufC* is already on the cleanup stack
// after a call to this method.
// ------------------------------------------------------------------------------
//
EXPORT_C HBufC* TXmlEngString::AllocAndFreeL()
{
    CleanupStack::PushL((TAny*)iString);  // PushL()  
    HBufC* ret = HBufCFromXmlCharL(iString); // inlined AllocL();
    CleanupStack::PopAndDestroy();
    iString = NULL;
    return ret;
}

/**
Allocates heap descriptor as AllocLC() and frees internal c-string.

More details in AllocAndFreeL() description.
*/
EXPORT_C HBufC* TXmlEngString::AllocAndFreeLC()
{
    // inlined AllocAndFreeL():
    CleanupStack::PushL((TAny*)iString);  // PushL()
    HBufC* hbuf = HBufCFromXmlCharL(iString); // inlined AllocL();
    CleanupStack::PopAndDestroy(); // iString
    iString = NULL;
    //
    CleanupStack::PushL(hbuf);
    return hbuf;
}


EXPORT_C void TXmlEngString::AppendL(TXmlEngString str)
    {
    if(str.iString)
        {
        TUint len1 = iString ? Size(): 0;
        TUint len2 = str.Size();
        char* res = new (ELeave) char[len1 + len2 + 1];
        OOM_IF_NULL(res);
        if (iString)
            memcpy(res, iString, len1);
        memcpy(res+len1, str.iString, len2);
        res[len1+len2] = 0;
        delete iString;
        iString = res;
        }
    }

EXPORT_C void TXmlEngString::AppendL(TXmlEngString str1, TXmlEngString str2)
    {   
        AppendL(str1);
        AppendL(str2);
    }