diff -r 514d98f21c43 -r 4ea6f81c838a osncore/osncore/src/ustringimpl.cpp
--- a/osncore/osncore/src/ustringimpl.cpp	Mon Jun 21 16:15:51 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,673 +0,0 @@
-/*
-* Copyright (c) 2007-2008 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:  String class implementation
-*
-*/
-
-
-#include "ustringimpl.h"
-
-#include <gstring.h>
-#include <stdexcept>
-#if defined(__GNUC__)
-#include <string.h>
-#else
-#include <string.h>
-#endif
-#include <osn/osnnew.h>
-using namespace std;
-
- 
-namespace osncore
-{
-
-const int KMaxUtf8Length = 6;
-
-
-// -------------------------------------------------------------------------
-// Returns the byte count for aStr with aCharCount length
-// -------------------------------------------------------------------------
-//
-static long bytesFromCharacters(const Utf8* aStr, long aCharCount)
-    {
-    int byteCount = 0;
-    
-    if (aStr)
-        {
-        const char* srcEndOffset = g_utf8_offset_to_pointer(aStr,aCharCount); 
-        byteCount = srcEndOffset - aStr;    
-        }
-    
-    return byteCount;
-    }
-
-// -------------------------------------------------------------------------
-// Initializes the string from stack or heap depending on its length
-// -------------------------------------------------------------------------
-//
-void UStringImpl::initialize(const Utf8* aStr)
-    {
-    if (len < MAX_STR_LEN)
-        {
-        str = internalStr;
-        memcpy(internalStr, aStr, len);
-        }
-    else
-        {
-        str = (gchar*)calloc(len+1, sizeof (gchar));
-    	if(!str)
-    		{
-    		throw bad_alloc();
-    		}
-    	memcpy(str,aStr,len);
-    	isInHeap = true;
-        }
-	
-	str[len] = 0;
-	allocated_len = len+1;    
-    }
-    
-// -------------------------------------------------------------------------
-// Allocates memory from heap if needed, throws if allocation fails
-// -------------------------------------------------------------------------
-//
-void UStringImpl::checkBuffer(unsigned int aLength)
-	{
-	if (aLength < allocated_len)
-		{
-		return;
-		}
-    if (aLength >= MAX_STR_LEN)
-        {
-        if (!isInHeap) //str is in stack, move it to heap
-            {
-            gchar* temp = (gchar*)calloc(aLength + 1, sizeof(gchar));
-            if (!temp)
-                {
-        		throw bad_alloc();
-                }
-            if(str)
-                {
-                memcpy(temp, str, len);
-                }
-            str = temp;
-            isInHeap = true;
-            }
-        else
-            {
-        	gchar* tmp(0);
-        	tmp = (gchar*)realloc(str,aLength+1);
-        	if(!tmp)
-        		{
-        		throw bad_alloc();
-        		}
-        	str = tmp;
-            }
-        }
-    else
-        {
-        // if ustring is constructed with null or "" set internal buffer to
-        // point to str
-        if (!str)
-            str = internalStr;
-        }
-	allocated_len = aLength+1;
-
-     
-	// reset allocated space
-	memset(str+len, 0, allocated_len-len);
-	}
-// -------------------------------------------------------------------------
-// Implements the actual insertion functionality
-// -------------------------------------------------------------------------
-//
-void UStringImpl::insertImpl(unsigned int aIndex, const char* aInsertChars, unsigned int aInsertLength)
-	{
-    // Ensure that we have enough space.
-	checkBuffer(len + aInsertLength); 
-	// Move tail to make space for inserted characters.
-    memmove(str+aIndex+aInsertLength, str+aIndex, len-aIndex);
-    // Insert characters.
-    memcpy(str+aIndex, aInsertChars, aInsertLength);
-    // Update len
-    len += aInsertLength;
-	}  
-// -------------------------------------------------------------------------
-// Implements the actual append functionality
-// -------------------------------------------------------------------------
-//
-void UStringImpl::appendImpl(const char* aStr, unsigned int aLength)
-	{
-	insertImpl(len, aStr, aLength);
-	}
-// -------------------------------------------------------------------------
-// Implements the actual erase functionality
-// -------------------------------------------------------------------------
-//
-void UStringImpl::eraseImpl(unsigned int aIndex, unsigned int aLength)
-	{
-	if(aIndex > len)
-		{
-		throw out_of_range("out_of_range");
-		}
-	
-	if(aIndex+aLength >= len)
-		{
-		// erase from given index to end of the string
-		if(aIndex<len)
-			{
-			len = aIndex;
-			}
-		memset(str+aIndex,0,len-aIndex);
-		}
-	else
-		{
-		// Move tail (remove begin or between) to given index.
-	    memmove(str+aIndex, str+aIndex+aLength, len-(aIndex+aLength));
-		len -=  aLength;
-		memset(str+len,0,allocated_len-len);
-		}
-	}
-    
-// -------------------------------------------------------------------------
-// Constructor
-// -------------------------------------------------------------------------
-//
-UStringImpl::UStringImpl():str(0),len(0),allocated_len(0), isInHeap(0)
-	{
-#ifdef _DEBUG
-	g_setenv("G_SLICE","always-malloc",1);
-#endif
-	}
-// -------------------------------------------------------------------------
-// Constructs the string from aStr
-// -------------------------------------------------------------------------
-//
-UStringImpl::UStringImpl(const Utf8* aStr)
-    :str(0),len(0),allocated_len(0), isInHeap(0)
-    {
-#ifdef _DEBUG    
-    g_setenv("G_SLICE","always-malloc",1);
-#endif    
-    //NULL byte not accepted
-    if (aStr)
-        {
-        len = strlen(aStr); 
-        initialize(aStr);
-        }   
-    }
-
-// -------------------------------------------------------------------------
-// Constructs the string from aStr with aByteCount length
-// -------------------------------------------------------------------------
-//
-UStringImpl::UStringImpl(const Utf8* aStr, int aByteCount)
-    :str(0),len(0),allocated_len(0), isInHeap(0)
-    {
-#ifdef _DEBUG    
-    g_setenv("G_SLICE","always-malloc",1);
-#endif    
-    //NULL byte not accepted
-    if (aStr)
-        {
-        len = aByteCount;
-        initialize(aStr);
-        }    
-    }
-
-// -------------------------------------------------------------------------
-// Constructs the string from aCodePoint
-// -------------------------------------------------------------------------
-//
-UStringImpl::UStringImpl(Unicode aCodePoint)
-    :str(0),len(0),allocated_len(0), isInHeap(0)
-    {
-#ifdef _DEBUG    
-    g_setenv("G_SLICE","always-malloc",1);
-#endif    
-        
-    char string[KMaxUtf8Length]; 
-    long usedBytes = g_unichar_to_utf8((unsigned int)aCodePoint,&string[0]);
-    if(usedBytes > 0)
-        {
-        len = usedBytes;
-        initialize(&string[0]);
-        }
-    }
-
-// -------------------------------------------------------------------------
-// Copy constructor
-// -------------------------------------------------------------------------
-//
-UStringImpl::UStringImpl(const UStringImpl& aUStringImpl)
-    :str(0),len(aUStringImpl.len),allocated_len(0), isInHeap(0)
-    {
-#ifdef _DEBUG    
-    g_setenv("G_SLICE","always-malloc",1);
-#endif    
-    if(aUStringImpl.str)
-        {
-        initialize(aUStringImpl.str);
-        }
-    }
-
-
-// -------------------------------------------------------------------------
-// Destructor
-// -------------------------------------------------------------------------
-//
-UStringImpl::~UStringImpl()
-	{
-	if (str && isInHeap)
-	    {
-	    delete str;
-	    }
-	}	
-// -------------------------------------------------------------------------
-// Returns true if the string is empty
-// -------------------------------------------------------------------------
-//
-bool UStringImpl::empty()const
-	{
-	return (len > 0) ? false : true;
-	}
-
-// -------------------------------------------------------------------------
-// Returns true if the string is a null string
-// -------------------------------------------------------------------------
-//
-bool UStringImpl::null()const
-	{
-	return (str) ? false : true;
-	}
-	
-// -------------------------------------------------------------------------
-// Returns the length of the string in characters 
-// -------------------------------------------------------------------------
-//
-long UStringImpl::length()const
-    {
-    long ret(0);
-    if(str && (len > 0))
-        {
-        ret = g_utf8_strlen(str, len);
-        }
-    return ret;    
-    }        
-
-// -------------------------------------------------------------------------
-// Returns the length of the string in bytes
-// -------------------------------------------------------------------------
-//
-long UStringImpl::bytes()const
-    {
-    return (long)len;    
-    }        
-
-	
-// -------------------------------------------------------------------------
-// Returns the utf8 type string
-// -------------------------------------------------------------------------
-//
-const Utf8* UStringImpl::utf8()const
-    {
-    return str;
-    }
-    
-// -------------------------------------------------------------------------
-// Compares the string to another UString with strcmp
-// -------------------------------------------------------------------------
-//
-int UStringImpl::compare(const UStringImpl& aUStringImpl)const
-    {
-    int ret(1);
-    if(!str && !aUStringImpl.str)
-        {
-        ret = 0;    
-        }
-    else if(str && aUStringImpl.str)
-        {
-        ret = strcmp(str, aUStringImpl.str);
-        }
-    else if(!str)
-        {
-        ret = -1;
-        }
-  
-    return ret;
-    }	 	
-// -------------------------------------------------------------------------
-// Compares the string to Utf8 string with strcmp
-// -------------------------------------------------------------------------
-//
-int UStringImpl::compare(const Utf8* aStr)const
-    {    
-    int ret(1);
-    if(str && aStr)
-        {
-        ret = strcmp(str, aStr);
-        }
-    else if(!str && !strlen(aStr))
-        {
-        ret = 0;    
-        }
-    else if(!str)
-        {
-        ret = -1;
-        }
-   
-    return ret;
-    }	 
-
-// -------------------------------------------------------------------------
-// Compares the string to another UString using the linguistically
-// correct rules for the current locale
-// -------------------------------------------------------------------------
-//
-int UStringImpl::compareC(const UStringImpl& aUStringImpl)const
-    {
-    int ret(1);
-    if(!str && !aUStringImpl.str)
-        {
-        ret = 0;    
-        }
-    else if(str && aUStringImpl.str)
-        {
-        ret = g_utf8_collate(str, aUStringImpl.str);
-        }
-    else if(!str)
-        {
-        ret = -1;
-        }
-  
-    return ret;
-    }	 	
-// -------------------------------------------------------------------------
-// Compares the string to Utf8 string using the linguistically
-// correct rules for the current locale
-// -------------------------------------------------------------------------
-//
-int UStringImpl::compareC(const Utf8* aStr)const
-    {    
-    int ret(1);
-    if(str && aStr)
-        {
-        ret = g_utf8_collate(str, aStr);
-        }
-    else if(!str && !strlen(aStr))
-        {
-        ret = 0;    
-        }
-    else if(!str)
-        {
-        ret = -1;
-        }
-   
-    return ret;
-    } 
-
-// -------------------------------------------------------------------------
-// Appends another UString to this string 
-// -------------------------------------------------------------------------
-//
-void UStringImpl::append(const UStringImpl& aUStringImpl)
-    {
-    if(str && aUStringImpl.str)
-        {
-        appendImpl(aUStringImpl.str, aUStringImpl.len);
-        }
-    }	 
-// -------------------------------------------------------------------------
-// Appends a Utf8 string to this string
-// -------------------------------------------------------------------------
-//
-void UStringImpl::append(const Utf8* aStr)
-    {
-    if(aStr && (strlen(aStr) !=0))
-        {
-        appendImpl(aStr, strlen(aStr));
-        }
-    }
-
-// -------------------------------------------------------------------------
-// Inserts Utf8 string to this string 
-// -------------------------------------------------------------------------
-//
-void UStringImpl::insert( 
-    long aPos, 
-    const Utf8* aStr)
-    {
-   
-    if(aStr)
-       {
-       if (!str)
-           checkBuffer(0);
-       long dstCharCount = g_utf8_strlen(str, -1);
-       if(aPos < -1 || aPos > dstCharCount)
-           {
-           throw out_of_range("out_of_range");  
-           }
-        // find out byte position for given character position
-       long startBytePos(-1);
-       if(aPos >= 0)
-           {
-           if(str)
-               {
-               const char* startOffset = g_utf8_offset_to_pointer(str, aPos);
-               startBytePos = startOffset - str;
-               }
-           }
-       if(aPos == -1)
-    	   {
-    	   appendImpl(aStr, strlen(aStr));
-    	   }
-       else
-    	   {
-    	   insertImpl(startBytePos, aStr, strlen(aStr));
-    	   }
-       }
-    }
-   
-// -------------------------------------------------------------------------
-// Inserts Utf8 string to this string with length of the Utf8 specified
-// -------------------------------------------------------------------------
-//
-void UStringImpl::insert( 
-    long aPos, 
-    const Utf8* aStr,
-    long aCharCount)
-    {
-    if (aCharCount < 1)
-        {
-        throw out_of_range("out_of_range");    
-        }
-    
-    if (aStr)
-        {
-        long srcByteLen = bytesFromCharacters(aStr, aCharCount);
-        if(!str)
-            checkBuffer(0);
-        
-        // calculate how many bytes are needed for given characters
-        long srcCharCount = g_utf8_strlen(aStr, srcByteLen);
-        long dstCharCount = g_utf8_strlen(str, -1); 
-        long startBytePos(-1); // appends end of the string
-
-        if(aPos < -1 || aPos > dstCharCount-1 || aCharCount > srcCharCount)
-            {
-            throw out_of_range("out_of_range");  
-            }
-           
-        if(aPos != -1)
-            {
-            const char* startOffset = g_utf8_offset_to_pointer(str, aPos); 
-            startBytePos = startOffset - str; 
-            }
-        const char* endOffset = g_utf8_offset_to_pointer(aStr, aCharCount);
-        long insertByteLength = endOffset - aStr;   
-
-        if(aPos == -1)
-            {
-            appendImpl(aStr, insertByteLength);
-            }
-        else
-            {
-            insertImpl(startBytePos, aStr, srcByteLen);
-            }
-        }
-    }
-
-// -------------------------------------------------------------------------
-// Replaces Utf8 string to this string 
-// -------------------------------------------------------------------------
-//
-void UStringImpl::replace(
-    long aPos, 
-    const Utf8* aStr)
-    {
-    if (aStr)
-        {
-        if (!str)
-            checkBuffer(0);
-        
-        long srcByteLen = strlen(aStr);
-        long srcCharCount = g_utf8_strlen(aStr,-1); 
-        long dstCharCount = g_utf8_strlen(str, -1);
-        if(aPos > dstCharCount || aPos < 0)
-            {
-            throw out_of_range("out_of_range");    
-            }
-        
-        // calculate start byte position
-        if(str)
-            {
-            const char* startOffset = g_utf8_offset_to_pointer(str, aPos);
-            long startBytePos = startOffset - str; 
-            
-            // calculate erasable character count in bytes
-                if(startOffset)
-                    {
-	                const char* endOffset = g_utf8_offset_to_pointer(startOffset, srcCharCount);
-	                long eraseByteLength = endOffset - startOffset;  
-	                // erase existing characters
-	                eraseImpl(startBytePos, eraseByteLength);
-                    }
-            insertImpl(startBytePos, aStr, srcByteLen);
-            }
-        }
-   }  
-      
-   
-// -------------------------------------------------------------------------
-// Replaces a Utf8 string to this string with length of the Utf8 specified
-// -------------------------------------------------------------------------
-//
-void UStringImpl::replace(
-    long aPosOffset, 
-    const Utf8* aStr,
-    long aCharCount)
-    {
-    if (aCharCount < 1)
-        {
-        throw out_of_range("out_of_range");    
-        }
-        
-    if (aStr)
-        {
-        long srcByteLen = bytesFromCharacters(aStr, aCharCount);
-        if(!str)
-            checkBuffer(0);
-        
-        long srcCharCount = g_utf8_strlen(aStr, srcByteLen); 
-        long dstCharCount = g_utf8_strlen(str, -1);
-        if(aPosOffset > dstCharCount || aPosOffset < 0 || aCharCount > srcCharCount)
-            {
-            throw out_of_range("out_of_range");    
-            }
-        // calculate start byte position
-        if(str)
-            {
-            const char* startOffset = g_utf8_offset_to_pointer(str, aPosOffset);
-            long startBytePos = startOffset - str; 
-        
-        // calculate erasable character count in bytes
-            if(startOffset)
-                {
-                const char* endOffset = g_utf8_offset_to_pointer(startOffset, srcCharCount);
-                long eraseByteLength = endOffset - startOffset;  
-                // erase existing characters
-                eraseImpl(startBytePos, eraseByteLength);
-                }
-            insertImpl(startBytePos, aStr, srcByteLen);
-            }
-        }
-   }  
- 
-// -------------------------------------------------------------------------
-// Erases aCharCount characters from the string at position specified by 
-// aPosOffset
-// -------------------------------------------------------------------------
-//
-void UStringImpl::erase(
-    long aPosOffset, 
-    long aCharCount)
-    {
-    
-    if(str)
-        {
-        long srcCharCount = g_utf8_strlen(str, -1); 
-        
-        if (aPosOffset < 0 || aCharCount < 1 || aCharCount > srcCharCount)
-            {
-            throw out_of_range("out_of_range"); 
-            }
-        
-        // calc startpos
-        const char* startOffset = g_utf8_offset_to_pointer(str, aPosOffset); 
-        long startBytePos = startOffset - str; 
-        
-        // calc bytes to erase
-        const char* endOffset = g_utf8_offset_to_pointer(startOffset, aCharCount); 
-        long eraseByteLength = endOffset - startOffset; 
-       
-        eraseImpl(startBytePos, eraseByteLength);
-        }
-   }  
-
-// -------------------------------------------------------------------------
-// Returns unicode at aIndex position in the string
-// -------------------------------------------------------------------------
-//
-Unicode UStringImpl::operator[](long aIndex)
-   {
-   Unicode ret(0xF8FF);
-    
-   if(str)
-       {
-       long charCount = g_utf8_strlen(str, -1);
-       if(aIndex < 0 || aIndex > charCount-1)
-           {
-           throw out_of_range("out_of_range"); 
-           }
-       // calc startpos
-       const char* uniChar = g_utf8_offset_to_pointer(str, aIndex); 
-        
-       ret = g_utf8_get_char(uniChar);        
-       }
-   return ret;     
-   }  
-
-}
-    		
-