--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/osncore/osncore/src/alfstring.cpp Thu Dec 17 08:56:02 2009 +0200
@@ -0,0 +1,299 @@
+/*
+* Copyright (c) 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: Osn String Implementation.
+*
+*/
+
+#if defined(__GNUC__)
+#include <string.h>
+#include <assert.h>
+#else
+#include <e32base.h>
+#include <libc/string.h>
+#include <libc/assert.h>
+#endif
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "osn/alfstring.h"
+#include "stringmacros.h"
+//#include "char.h"
+#include "alfstringdata.h"
+//#include "CHARCONV.H"
+#include <osn/osnnew.h>
+#include <osn/osnbadalloc.h>
+#define CHECK_FOR_HANDLE_LEAKS 0
+
+using namespace std;
+namespace osncore
+ {
+
+
+
+
+#define IS_ASCII_QCHAR(c) ((c).unicode() > 0 && (c).unicode() <= 0xff)
+
+
+
+
+EXPORT_C CAlfString::CAlfString()
+ :internalData(new(S60)SAlfStringData())
+ {
+ }
+
+
+
+EXPORT_C CAlfString::~CAlfString()
+ {
+
+ if(internalData.get())
+ {
+ internalData->deref();
+ if(internalData->refCount != 0)
+ {
+ internalData.release(); // don't kill it, we have ref
+ }
+ }
+ }
+
+
+
+
+EXPORT_C CAlfString::CAlfString(const char *chs)
+ :internalData(new(S60)SAlfStringData())
+ {
+ internalData->initialize(chs, strlen(chs));
+
+ }
+
+
+
+EXPORT_C CAlfString::CAlfString(const CAlfString &qs)
+ :internalData(qs.internalData.get())
+ {
+ internalData->ref();
+ }
+
+EXPORT_C CAlfString &CAlfString::operator=(const CAlfString &qs)
+ {
+ if (this == &qs)
+ return *this;
+ qs.internalData->ref(); // increase source ref count
+ internalData->deref();
+ if(internalData->refCount != 0)
+ {
+ internalData.release();
+ }
+
+ internalData.reset(qs.internalData.get());
+ return *this;
+ }
+
+EXPORT_C const char* CAlfString::latin1() const
+{
+ return internalData->ascii();
+}
+
+
+
+EXPORT_C CAlfString::CAlfString(const char *chs, int len)
+ : internalData(new(S60)SAlfStringData())
+ {
+
+ internalData->initialize(chs, len);
+
+ }
+
+EXPORT_C int CAlfString::compare(const CAlfString& s) const
+{
+ //if (internalData->_isAsciiValid && s.internalData->_isAsciiValid)
+ return strcmp(latin1(), s.latin1());
+ //return ucstrcmp(*this,s);
+ // return -1;
+}
+
+
+EXPORT_C CAlfString& CAlfString::append(const CAlfString &s)
+ {
+ return insert(internalData->_length, s);
+ }
+
+
+EXPORT_C CAlfString &CAlfString::insert(uint index, const char *insertChars, uint insertLength)
+{
+ if (insertLength == 0)
+ return *this;
+
+ //detach();
+
+ // if (internalData->_isAsciiValid){
+ uint originalLength = internalData->_length;
+ char *targetChars;
+
+ // Ensure that we have enough space.
+ if( !setLength (originalLength + insertLength) )
+ {
+ throw std::bad_alloc();
+ //return *this;
+ }
+
+ targetChars = (char *)internalData->ascii();
+
+ // Move tail to make space for inserted characters.
+ memmove (targetChars+index+insertLength, targetChars+index, originalLength-index);
+
+ // Insert characters.
+ memcpy (targetChars+index, insertChars, insertLength);
+
+ internalData->_isUnicodeValid = 0;
+ //}
+ /*
+ else if (dataHandle[0]->_isUnicodeValid){
+ uint originalLength = dataHandle[0]->_length;
+ QChar *targetChars;
+
+ // Ensure that we have enough space.
+ if( !setLength (originalLength + insertLength) ) return *this;
+ targetChars = (QChar *)unicode();
+
+ // Move tail to make space for inserted characters.
+ memmove (targetChars+(index+insertLength), targetChars+index, (originalLength-index)*sizeof(QChar));
+
+ // Insert characters.
+ uint i = insertLength;
+ QChar *target = targetChars+index;
+
+ while (i--)
+ *target++ = *insertChars++;
+ }
+ else
+ FATAL("invalid character cache",0);
+ */
+
+ return *this;
+}
+
+
+
+EXPORT_C CAlfString& CAlfString::insert(uint index, const CAlfString &s)
+{
+ if (s.internalData->_length == 0)
+ return *this;
+
+#ifdef QSTRING_DEBUG_UNICODE
+ //forceUnicode();
+#endif
+
+ // if (internalData->_isAsciiValid) //&& s.isAllLatin1()
+ // {
+ insert(index, s.latin1(), s.internalData->_length);
+ // }
+ /*
+ else
+ {
+ uint insertLength = qs.dataHandle[0]->_length;
+ uint originalLength = dataHandle[0]->_length;
+ AlfChar *targetChars;
+
+ // Ensure that we have enough space.
+ if( !setLength (originalLength + insertLength) ) return *this;
+ targetChars = forceUnicode();
+
+ // Move tail to make space for inserted characters.
+ memmove (targetChars+(index+insertLength), targetChars+index, (originalLength-index)*sizeof(QChar));
+
+ // Insert characters.
+ if (qs.dataHandle[0]->_isAsciiValid){
+ uint i = insertLength;
+ AlfChar *target = targetChars+index;
+ char *a = (char *)qs.ascii();
+
+ while (i--)
+ *target++ = *a++;
+ }
+ else {
+ AlfChar *insertChars = (AlfChar *)qs.unicode();
+ memcpy (targetChars+index, insertChars, insertLength*sizeof(QChar));
+ }
+
+ internalData->_isAsciiValid = 0;
+ }
+ */
+
+ return *this;
+}
+
+
+// Increase buffer size if necessary. Newly allocated
+// bytes will contain garbage.
+bool CAlfString::setLength(uint newLen)
+{
+
+ if (newLen == 0) {
+ //setUnicode(0, 0);
+ return true;
+ }
+
+ // Missing optimization: Could avoid copying characters we are going to remove
+ // by making a special version of detach().
+// detach();
+
+// ASSERT(dataHandle != shared_null_handle);
+
+/*
+#ifdef QSTRING_DEBUG_UNICODE
+ forceUnicode();
+#endif
+*/
+
+ // if (internalData->_isAsciiValid){
+ if (newLen+1 > internalData->_maxAscii) {
+ if( internalData->increaseAsciiSize(newLen+1) == false ) return false;
+ }
+ // Ensure null termination, although newly allocated
+ // bytes contain garbage.
+ internalData->_ascii[newLen] = 0;
+ // }
+ /*else if (internalData->_isUnicodeValid){
+ if (newLen > internalData->_maxUnicode) {
+ if( internalData->increaseUnicodeSize(newLen) == false ) return false;
+ }
+ }*/
+/*
+ else
+ FATAL("invalid character cache",0);
+*/
+
+ internalData->_length = newLen;
+ return true;
+}
+
+
+
+EXPORT_C bool CAlfString::operator==(const CAlfString &s1)const
+ {
+ // if (internalData->_isAsciiValid && s1.internalData->_isAsciiValid)
+ // {
+ return strcmp(latin1(), s1.latin1()) == 0;
+ // }
+ // return false;
+ /*
+ return s1.dataHandle[0]->_length == s2.dataHandle[0]->_length
+ && memcmp(s1.unicode(), s2.unicode(), s1.dataHandle[0]->_length * sizeof(QChar)) == 0;
+ */
+ }
+
+
+
+}