/*

* 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;

        */

    }

}