diff -r 000000000000 -r e35f40988205 xml/libxml2libs/src/xmlengineutils/xmlengxmlstring.cpp --- /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 +#include +#include + +#include +#include + +#include +#include + +//----------------------------------------------------------- TXmlEngConstString + +// ------------------------------------------------------------------------------ +// Compares two strings. +// +// @return Result as strcmp() +// ------------------------------------------------------------------------------ +// +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 Size() != Length() +// ------------------------------------------------------------------------------ +// +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 (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 (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); + } +