/*
* 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 data implementation.
*
*/


#include <stdio.h>
#include <stdarg.h>

#if defined(__GNUC__)
#include <string.h>
#else
#include <libc/string.h>
#endif

#include <osn/osntypes.h>

#include "alfstringdata.h"
//#include "osn/char.h"
#include <osn/osnbadalloc.h>

using namespace std;

namespace osncore
    {
        
    
   
// -------------------------------------------------------------------------
// stringData
// -------------------------------------------------------------------------
SAlfStringData::SAlfStringData() :  refCount(1), /*_unicode(0),*/ _ascii(0), _maxAscii(QS_INTERNAL_BUFFER_CHARS), _isAsciiValid(1)
{
//#ifdef QSTRING_DEBUG_ALLOCATIONS
 //   stringDataInstances++;
//#endif
	refCount = 1;
 	_length=0;
//	_unicode = 0;
	_isUnicodeValid=0;
	_isAsciiValid = 1;
	_isHeapAllocated=0;
    _ascii = _internalBuffer;
    _internalBuffer[0] = 0;
}

SAlfStringData::~SAlfStringData()
{
  //  ASSERT(refCount == 0);
 /*   if (_unicode && !isUnicodeInternal())
    {
    DELETE_QCHAR(_unicode);	
    }
   */     
    if (_ascii && !isAsciiInternal())
    {
    DELETE_CHAR(_ascii);	
    }
     
}


// Copy data
void SAlfStringData::initialize(const char *a, int l)
{
    refCount = 1;
    _length = l;
   // _unicode = 0;
    _isUnicodeValid = 0;
    _maxUnicode = 0;
    _isAsciiValid = 1;
    _isHeapAllocated = 0;

   if (l > QS_INTERNAL_BUFFER_CHARS) 
    {
        _maxAscii = ALLOC_CHAR_GOOD_SIZE(l+1);
        _ascii = ALLOC_CHAR(_maxAscii);
    //Make sure we have memory before doing data copy.
    if(_ascii)
    	{
      	if (a)
      		{
      		memcpy(_ascii, a, l);	
      		}
      	_ascii[l] = 0;
    	}
    else{
        _length = 0;
        refCount = 0;
        _length = 0;
       // _unicode = 0;
        _isUnicodeValid = 0;
        _maxUnicode = 0;
        _isAsciiValid = 1;
        _isHeapAllocated = 0;
        throw bad_alloc();
    	}
    } 
    else {
        _maxAscii = QS_INTERNAL_BUFFER_CHARS;
        _ascii = _internalBuffer;
        if (a)
            memcpy(_internalBuffer, a, l);
        _internalBuffer[l] = 0;
    }
    
   
}


bool SAlfStringData::increaseAsciiSize(uint size)
{
    //ASSERT(this != QString::shared_null);

    uint newSize = (uint)ALLOC_CHAR_GOOD_SIZE((size * 3 + 1) / 2);

	/*
    if (!_isAsciiValid)
        return false;
    */
   // ASSERT(_isAsciiValid);

    if (isAsciiInternal()) {
        char *newAscii = ALLOC_CHAR(newSize);
        if( !newAscii ) return false;
        
        if (_length)
            memcpy(newAscii, _ascii, _length);
        _ascii = newAscii;
    } else {
        char* ap = _ascii;
        _ascii = REALLOC_CHAR( _ascii, newSize );
        
        if( !_ascii )
        {
            // memory manager won't delete the original pointer if realloc failed
            _ascii = ap;
            return false;
        }        
    }

    _maxAscii = newSize;
    _isAsciiValid = 1;
    _isUnicodeValid = 0;
    return true;
}





char* SAlfStringData::ascii()
{
// return _isAsciiValid ? _ascii :0;	
return _ascii;
}


/*
AlfChar *SAlfStringData::makeUnicode()
{
    //ASSERT(this != QString::shared_null);

    if (_isAsciiValid){
        char copyBuf[QS_INTERNAL_BUFFER_CHARS];
     //   char *str;

        if (_unicode && !isUnicodeInternal())
            DELETE_QCHAR(_unicode);

        if (_length <= QS_INTERNAL_BUFFER_UCHARS){
            if (isAsciiInternal()) {
                uint i = _length;
                char *tp = &copyBuf[0], *fp = _ascii;
                while (i--)
                    *tp++ = *fp++;
              //  str = &copyBuf[0];
                _isAsciiValid = 0;
            }
            else
                {
               // str = _ascii;
                
                }
            _unicode = (AlfChar *)_internalBuffer;
            _maxUnicode = QS_INTERNAL_BUFFER_UCHARS;
        }
        else {
            uint newSize = ALLOC_QCHAR_GOOD_SIZE(_length);
            _unicode = ALLOC_QCHAR(newSize);
            if( !_unicode )
            {
                _maxUnicode = 0;
                return 0;    
            }
            _maxUnicode = newSize;
        //    str = _ascii;
        }
   //     uint i = _length;
   //     AlfChar *cp = _unicode;
   //     while ( i-- )
   //         *cp++ = *str++;

        _isUnicodeValid = 1;
    }
  //  else if (!_isUnicodeValid)
  //      FATAL("invalid character cache",0);

    return _unicode;
}

*/
} // osncore