--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xml/libxml2libs/src/xmlengineutils/xmlengxmlstring.cpp Thu Dec 17 09:29:21 2009 +0200
@@ -0,0 +1,306 @@
+// 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);
+ }
+