android-2.0.1_r1/s

/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
// -*- c++ -*-
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

//               O S C L _ S T R I N G   C L A S S

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

// - - Inclusion - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#include "oscl_string_containers.h"
#include "oscl_stdstring.h"
#include "oscl_error.h"

// **************************************************************
//                   CHeapRep Implementation
// **************************************************************

OSCL_EXPORT_REF void CHeapRep::set_rep(CHeapRep*& aRep, Oscl_DefAlloc& aAlloc, const char* cp, uint32 len)
//set heap rep to new string.
{
    CHeapRep*newrep = New(aAlloc);
    if (newrep
            && newrep->set(len, cp, aAlloc))
    {
        CHeapRep::assign(aRep, newrep, aAlloc);
    }
    else
    {
        //could not allocate newrep or could not allocate buffer.
        if (newrep)
            aAlloc.deallocate(newrep);
        OsclError::Leave(OsclErrNoMemory);//no memory
    }
}

// **************************************************************
OSCL_EXPORT_REF void CHeapRep::set_rep(CHeapRep*& aRep, Oscl_DefAlloc& aAlloc, const oscl_wchar* cp, uint32 len)
//set heap rep to new string.
{
    CHeapRep*newrep = New(aAlloc);
    if (newrep
            && newrep->set(len, cp, aAlloc))
    {
        CHeapRep::assign(aRep, newrep, aAlloc);
    }
    else
    {
        //could not allocate newrep or could not allocate buffer.
        if (newrep)
            aAlloc.deallocate(newrep);
        OsclError::Leave(OsclErrNoMemory);//no memory
    }
}

// **************************************************************
OSCL_EXPORT_REF void CHeapRep::append_rep(CHeapRep*& aRep, Oscl_DefAlloc& aAlloc, const char* cp, uint32 len)
//set heap rep to current string plus new string.
{
    CHeapRep*newrep = New(aAlloc);
    if (newrep
            && newrep->append((aRep) ? aRep->size : 0, (char*)((aRep) ? aRep->buffer : NULL), len, cp, aAlloc))
    {
        CHeapRep::assign(aRep, newrep, aAlloc);
    }
    else
    {
        //could not allocate newrep or could not allocate buffer.
        if (newrep)
            aAlloc.deallocate(newrep);
        OsclError::Leave(OsclErrNoMemory);//no memory
    }
}

// **************************************************************
OSCL_EXPORT_REF void CHeapRep::append_rep(CHeapRep*& aRep, Oscl_DefAlloc& aAlloc, const oscl_wchar* cp, uint32 len)
//set heap rep to current string plus new string.
{
    CHeapRep*newrep = New(aAlloc);
    if (newrep
            && newrep->append((aRep) ? aRep->size : 0, (oscl_wchar*)((aRep) ? aRep->buffer : NULL), len, cp, aAlloc))
    {
        CHeapRep::assign(aRep, newrep, aAlloc);
    }
    else
    {
        //could not allocate newrep or could not allocate buffer.
        if (newrep)
            aAlloc.deallocate(newrep);
        OsclError::Leave(OsclErrNoMemory);//no memory
    }
}

// **************************************************************
OSCL_EXPORT_REF void CHeapRep::assign(CHeapRep*& dest, CHeapRep* src, Oscl_DefAlloc &alloc)
{
    if (src)
        src->add_ref();
    if (dest)
        dest->remove_ref(alloc);
    dest = src;
}

// **************************************************************
CHeapRep* CHeapRep::New(Oscl_DefAlloc &alloc)
{
    OsclAny *ptr = alloc.ALLOCATE(sizeof(CHeapRep));
    if (ptr)
    {
        CHeapRep*newrep = new(ptr) CHeapRep;
        return newrep;
    }
    return NULL;
}

// **************************************************************
OSCL_EXPORT_REF bool CHeapRep::set(uint32 nsz, const char*cp, Oscl_DefAlloc &alloc)
{
    // allocate enough space including terminator
    OsclAny* ptr = alloc.ALLOCATE(sizeof(char) * (nsz + 1));
    if (!ptr)
    {
        refcount = 0;
        size = 0;
        maxsize = 0;
        buffer = NULL;
        return false;//can't allocate buffer.
    }
    refcount = 0;
    size = nsz;
    maxsize = nsz;
    buffer = ptr;
    if (cp)
        oscl_strncpy((char*)buffer, cp, size);
    ((char*)buffer)[size] = '\0';
    return true;
}
OSCL_EXPORT_REF bool CHeapRep::set(uint32 nsz, const oscl_wchar*cp, Oscl_DefAlloc &alloc)
{
    // allocate enough space including terminator
    OsclAny* ptr = alloc.ALLOCATE(sizeof(oscl_wchar) * (nsz + 1));
    if (!ptr)
    {
        refcount = 0;
        size = 0;
        maxsize = 0;
        buffer = NULL;
        return false;//can't allocate buffer.
    }
    refcount = 0;
    size = nsz;
    maxsize = nsz;
    buffer = ptr;
    if (cp)
        oscl_strncpy((oscl_wchar*)buffer, cp, size);
    ((oscl_wchar*)buffer)[size] = '\0';
    return true;
}

// **************************************************************
OSCL_EXPORT_REF bool CHeapRep::append(uint32 s1, const char*cp1,
                                      uint32 s2, const char*cp2,
                                      Oscl_DefAlloc &alloc)
{
    maxsize = s1 + s2;
    size = maxsize;
    // allocate enough space including terminator
    OsclAny* ptr = alloc.ALLOCATE(sizeof(char) * (maxsize + 1));
    if (!ptr)
    {
        refcount = 0;
        size = 0;
        maxsize = 0;
        buffer = NULL;
        return false;//can't allocate buffer.
    }
    refcount = 0;
    buffer = ptr;
    if (cp1)
        oscl_strncpy((char*)buffer, cp1, s1);
    ((char*)buffer)[s1] = '\0';
    if (cp2)
        oscl_strncat((char*)buffer, cp2, s2);
    ((char*)buffer)[size] = '\0';
    return true;
}

OSCL_EXPORT_REF bool CHeapRep::append(uint32 s1, const oscl_wchar*cp1,
                                      uint32 s2, const oscl_wchar*cp2,
                                      Oscl_DefAlloc &alloc)
{
    maxsize = s1 + s2;
    size = maxsize;
    // allocate enough space including terminator
    OsclAny* ptr = alloc.ALLOCATE(sizeof(oscl_wchar) * (maxsize + 1));
    if (!ptr)
    {
        refcount = 0;
        size = 0;
        maxsize = 0;
        buffer = NULL;
        return false;//can't allocate buffer.
    }
    refcount = 0;
    buffer = ptr;
    if (cp1)
        oscl_strncpy((oscl_wchar*)buffer, cp1, s1);
    ((oscl_wchar*)buffer)[s1] = '\0';
    if (cp2)
        oscl_strncat((oscl_wchar*)buffer, cp2, s2);
    ((oscl_wchar*)buffer)[size] = '\0';
    return true;
}

// **************************************************************
OSCL_EXPORT_REF void CHeapRep::add_ref()
{
    refcount++;
}

// **************************************************************
OSCL_EXPORT_REF void CHeapRep::remove_ref(Oscl_DefAlloc &alloc)
{
    --refcount;
    if (refcount == 0)
    {
        alloc.deallocate(buffer);
        alloc.deallocate(this);
    }
}

// **************************************************************
//                   OSCL_HeapStringA Implementation
//                   OSCL_wHeapStringA Implementation
// **************************************************************

void OSCL_HeapStringA::set_rep(const chartype* cp, uint32 len)
//set heap rep to new string.
{
    CHeapRep::set_rep(iRep, *iAlloc, cp, len);
}

void OSCL_wHeapStringA::set_rep(const chartype* cp, uint32 len)
//set heap rep to new string.
{
    CHeapRep::set_rep(iRep, *iAlloc, cp, len);
}

// **************************************************************
void OSCL_HeapStringA::append_rep(const chartype* cp, uint32 len)
//set heap rep to current string plus new string.
{
    CHeapRep::append_rep(iRep, *iAlloc, cp, len);
}

void OSCL_wHeapStringA::append_rep(const chartype* cp, uint32 len)
//set heap rep to current string plus new string.
{
    CHeapRep::append_rep(iRep, *iAlloc, cp, len);
}

// **************************************************************
void OSCL_HeapStringA::set_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    set_rep(cp, len);
}

void OSCL_wHeapStringA::set_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    set_rep(cp, len);
}


// **************************************************************
void OSCL_HeapStringA::append_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    append_rep(cp, len);
}

void OSCL_wHeapStringA::append_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    append_rep(cp, len);
}


// **************************************************************
void OSCL_HeapStringA::set_rep(const OSCL_String& src)
{
    set_rep(src.get_cstr(), src.get_size());
}

void OSCL_wHeapStringA::set_rep(const OSCL_wString& src)
{
    set_rep(src.get_cstr(), src.get_size());
}


// **************************************************************
void OSCL_HeapStringA::append_rep(const OSCL_String& src)
{
    append_rep(src.get_cstr(), src.get_size());
}

void OSCL_wHeapStringA::append_rep(const OSCL_wString& src)
{
    append_rep(src.get_cstr(), src.get_size());
}


// **************************************************************
OSCL_EXPORT_REF uint32 OSCL_HeapStringA::get_size() const
{
    if (iRep)
        return iRep->size;
    return 0;
}

OSCL_EXPORT_REF uint32 OSCL_wHeapStringA::get_size() const
{
    if (iRep)
        return iRep->size;
    return 0;
}

// **************************************************************
void OSCL_HeapStringA::set_len(uint32 len)
{
    iRep->size = len;
}

void OSCL_wHeapStringA::set_len(uint32 len)
{
    iRep->size = len;
}


// **************************************************************
OSCL_EXPORT_REF uint32 OSCL_HeapStringA::get_maxsize() const
{
    if (iRep)
        return iRep->maxsize;
    return 0;
}

OSCL_EXPORT_REF uint32 OSCL_wHeapStringA::get_maxsize() const
{
    if (iRep)
        return iRep->maxsize;
    return 0;
}


// **************************************************************
OSCL_EXPORT_REF const OSCL_HeapStringA::chartype* OSCL_HeapStringA::get_cstr() const
{
    if (iRep)
        return (chartype*)iRep->buffer;
    return NULL;
}

OSCL_EXPORT_REF const OSCL_wHeapStringA::chartype* OSCL_wHeapStringA::get_cstr() const
{
    if (iRep)
        return (chartype*)iRep->buffer;
    return NULL;
}


// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA::chartype* OSCL_HeapStringA::get_str() const
{
    if (iRep)
        return (chartype*)iRep->buffer;
    return NULL;
}

OSCL_EXPORT_REF OSCL_wHeapStringA::chartype* OSCL_wHeapStringA::get_str() const
{
    if (iRep)
        return (chartype*)iRep->buffer;
    return NULL;
}


// **************************************************************
void OSCL_HeapStringA::create(Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    iRep = NULL;
    if (alloc)
    {//use an allocator owned by the caller that may also have a ref counter.
        iAllocRef = ref;
        if (iAllocRef)
            iAllocRef->addRef();
        iAlloc = alloc;
    }
    else
    {//use a basic allocator that resides in this object.
        iAlloc = &iDefAlloc;
        iAllocRef = NULL;
    }
}

void OSCL_wHeapStringA::create(Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    iRep = NULL;
    if (alloc)
    {//use an allocator owned by the caller that may also have a ref counter.
        iAllocRef = ref;
        if (iAllocRef)
            iAllocRef->addRef();
        iAlloc = alloc;
    }
    else
    {//use a basic allocator that resides in this object.
        iAlloc = &iDefAlloc;
        iAllocRef = NULL;
    }
}


// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA::OSCL_HeapStringA()
{
    create(NULL, NULL);
    set_rep(NULL);
}
OSCL_EXPORT_REF OSCL_HeapStringA::OSCL_HeapStringA(Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set_rep(NULL);
}

OSCL_EXPORT_REF OSCL_wHeapStringA::OSCL_wHeapStringA()
{
    create(NULL, NULL);
    set_rep(NULL);
}
OSCL_EXPORT_REF OSCL_wHeapStringA::OSCL_wHeapStringA(Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set_rep(NULL);
}

// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA::OSCL_HeapStringA(const chartype* cp, Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set_rep(cp);
}

OSCL_EXPORT_REF OSCL_wHeapStringA::OSCL_wHeapStringA(const chartype* cp, Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set_rep(cp);
}

// **************************************************************
OSCL_EXPORT_REF void OSCL_HeapStringA::set(const chartype* cp, uint32 length)
{
    set_rep(cp, length);
    //just in case input string is shorter than 'length'
    iRep->size = oscl_strlen(get_cstr());
}

OSCL_EXPORT_REF void OSCL_wHeapStringA::set(const chartype* cp, uint32 length)
{
    set_rep(cp, length);
    //just in case input string is shorter than 'length'
    iRep->size = oscl_strlen(get_cstr());
}


// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA::OSCL_HeapStringA(const chartype* cp, uint32 length, Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set(cp, length);
}

OSCL_EXPORT_REF OSCL_wHeapStringA::OSCL_wHeapStringA(const chartype* cp, uint32 length, Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set(cp, length);
}

// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA::OSCL_HeapStringA(const OSCL_HeapStringA& src) : OSCL_String(src)
{
    create(NULL, NULL);
    *this = src;//uses heapstring=heapstring overload.
}
OSCL_EXPORT_REF OSCL_HeapStringA::OSCL_HeapStringA(const OSCL_HeapStringA& src, Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    *this = src;//uses heapstring=heapstring overload.
}

OSCL_EXPORT_REF OSCL_wHeapStringA::OSCL_wHeapStringA(const OSCL_wHeapStringA& src) : OSCL_wString(src)
{
    create(NULL, NULL);
    *this = src;//uses heapstring=heapstring overload.
}
OSCL_EXPORT_REF OSCL_wHeapStringA::OSCL_wHeapStringA(const OSCL_wHeapStringA& src , Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    *this = src;//uses heapstring=heapstring overload.
}

// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA::OSCL_HeapStringA(const OSCL_String& src, Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set_rep(src);
}

OSCL_EXPORT_REF OSCL_wHeapStringA::OSCL_wHeapStringA(const OSCL_wString& src , Oscl_DefAlloc *alloc, OsclRefCounter *ref)
{
    create(alloc, ref);
    set_rep(src);
}

// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA::~OSCL_HeapStringA()
{
    //remove ref to string rep
    if (iRep)
        iRep->remove_ref(*iAlloc);
    //remove ref to allocator.
    if (iAllocRef)
        iAllocRef->removeRef();
}

OSCL_EXPORT_REF OSCL_wHeapStringA::~OSCL_wHeapStringA()
{
    //remove ref to string rep
    if (iRep)
        iRep->remove_ref(*iAlloc);
    //remove ref to allocator.
    if (iAllocRef)
        iAllocRef->removeRef();
}

// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA& OSCL_HeapStringA::operator=(const OSCL_HeapStringA & src)
{
    //the allocators must match in order to re-use
    //the heap string representation.
    //Allocators match if they're the same object,
    //or they're both the default allocators.
    if (src.iRep
            && ((src.iAlloc == (Oscl_DefAlloc*)&src.iDefAlloc
                 && iAlloc == &iDefAlloc)
                || src.iAlloc == iAlloc))
    {
        CHeapRep::assign(iRep, src.iRep, *iAlloc);
    }
    else
    {//otherwise, create a new representation
        set_rep(src);
    }
    return (*this);
}

OSCL_EXPORT_REF OSCL_wHeapStringA& OSCL_wHeapStringA::operator=(const OSCL_wHeapStringA & src)
{
    //the allocators must match in order to re-use
    //the heap string representation.
    //Allocators match if they're the same object,
    //or they're both the default allocators.
    if (src.iRep
            && ((src.iAlloc == (Oscl_DefAlloc*)&src.iDefAlloc
                 && iAlloc == &iDefAlloc)
                || src.iAlloc == iAlloc))
    {
        CHeapRep::assign(iRep, src.iRep, *iAlloc);
    }
    else
    {//otherwise, create a new representation
        set_rep(src);
    }
    return (*this);
}

// **************************************************************
OSCL_EXPORT_REF OSCL_HeapStringA& OSCL_HeapStringA::operator=(const chartype * cp)
{
    set_rep(cp);
    return (*this);
}

OSCL_EXPORT_REF OSCL_wHeapStringA& OSCL_wHeapStringA::operator=(const chartype * cp)
{
    set_rep(cp);
    return (*this);
}

// **************************************************************
//                 CStackRep Implementation
// **************************************************************

OSCL_EXPORT_REF void CStackRep::set(const char* cp, uint32 len)
{
    if (len > maxsize)
        size = maxsize;//truncate
    else
        size = len;
    if (cp)
        oscl_strncpy((char*)buffer, cp, size);
    ((char*)buffer)[size] = '\0';
}
OSCL_EXPORT_REF void CStackRep::set(const oscl_wchar* cp, uint32 len)
{
    if (len > maxsize)
        size = maxsize;//truncate
    else
        size = len;
    if (cp)
        oscl_strncpy((oscl_wchar*)buffer, cp, size);
    ((oscl_wchar*)buffer)[size] = '\0';
}

// **************************************************************
OSCL_EXPORT_REF void CStackRep::append(const char* cp, uint32 alen)
{
    uint32 len = alen;
    if (size + len > maxsize)
        len = maxsize - size;//truncate
    if (len > 0)
    {
        size = size + len;
        oscl_strncat((char*)buffer, cp, len);
        ((char*)buffer)[size] = '\0';
    }
}
OSCL_EXPORT_REF void CStackRep::append(const oscl_wchar* cp, uint32 alen)
{
    uint32 len = alen;
    if (size + len > maxsize)
        len = maxsize - size;//truncate
    if (len > 0)
    {
        size = size + len;
        oscl_strncat((oscl_wchar*)buffer, cp, len);
        ((oscl_wchar*)buffer)[size] = '\0';
    }
}

// **************************************************************
//                CFastRep Implementation
// **************************************************************

OSCL_EXPORT_REF void CFastRep::set_r(const char* cp, uint32 len)
{
    size = len;
    maxsize = len;
    buffer = (OsclAny*)cp;
    writable = false;
}
OSCL_EXPORT_REF void CFastRep::set_r(const oscl_wchar* cp, uint32 len)
{
    size = len;
    maxsize = len;
    buffer = (OsclAny*)cp;
    writable = false;
}

// **************************************************************
OSCL_EXPORT_REF void CFastRep::set_w(char* cp, uint32 len, uint32 maxlen)
{
    size = len;
    maxsize = maxlen;
    buffer = (OsclAny*)cp;
    writable = true;
}
OSCL_EXPORT_REF void CFastRep::set_w(oscl_wchar* cp, uint32 len, uint32 maxlen)
{
    size = len;
    maxsize = maxlen;
    buffer = (OsclAny*)cp;
    writable = true;
}

// **************************************************************
OSCL_EXPORT_REF void CFastRep::append(const char* cp, uint32 len)
{
    uint32 ncopy = len;
    if (size + len > maxsize)
        ncopy = maxsize - size;//truncate
    if (ncopy > 0)
    {
        oscl_strncat((char*)buffer, cp, ncopy);
        size += ncopy;
        if (!writable)
            maxsize = size;
    }
}
OSCL_EXPORT_REF void CFastRep::append(const oscl_wchar* cp, uint32 len)
{
    uint32 ncopy = len;
    if (size + len > maxsize)
        ncopy = maxsize - size;//truncate
    if (ncopy > 0)
    {
        oscl_strncat((oscl_wchar*)buffer, cp, ncopy);
        size += ncopy;
        if (!writable)
            maxsize = size;
    }
}

// **************************************************************
//                   OSCL_FastString Implementation
//                   OSCL_wFastString Implementation
// **************************************************************
void OSCL_FastString::set_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    rep.set_r(cp, len);
}

void OSCL_wFastString::set_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    rep.set_r(cp, len);
}

// **************************************************************
void OSCL_FastString::append_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    rep.append(cp, len);
}

void OSCL_wFastString::append_rep(const chartype* cp)
{
    uint32 len = (cp) ? oscl_strlen(cp) : 0;
    rep.append(cp, len);
}


// **************************************************************
void OSCL_FastString::set_rep(const OSCL_String& src)
{
    //inherit the writable-ness of the source string.
    if (src.get_str())
        rep.set_w(src.get_str(), src.get_size(), src.get_maxsize());
    else
        rep.set_r(src.get_cstr(), src.get_size());
}

void OSCL_wFastString::set_rep(const OSCL_wString& src)
{
    //inherit the writable-ness of the source string.
    if (src.get_str())
        rep.set_w(src.get_str(), src.get_size(), src.get_maxsize());
    else
        rep.set_r(src.get_cstr(), src.get_size());
}

// **************************************************************
void OSCL_FastString::append_rep(const OSCL_String& src)
{
    rep.append(src.get_cstr(), src.get_size());
}

void OSCL_wFastString::append_rep(const OSCL_wString& src)
{
    rep.append(src.get_cstr(), src.get_size());
}

// **************************************************************
void OSCL_FastString::set_len(uint32 len)
{
    rep.size = len;
}
void OSCL_wFastString::set_len(uint32 len)
{
    rep.size = len;
}

// **************************************************************
OSCL_EXPORT_REF OSCL_FastString::OSCL_FastString()
{
    set_rep(NULL);
}

OSCL_EXPORT_REF OSCL_wFastString::OSCL_wFastString()
{
    set_rep(NULL);
}

// **************************************************************
OSCL_EXPORT_REF OSCL_FastString::OSCL_FastString(const chartype* cp)
{
    set_rep(cp);
}

OSCL_EXPORT_REF OSCL_wFastString::OSCL_wFastString(const chartype* cp)
{
    set_rep(cp);
}

// **************************************************************
OSCL_EXPORT_REF void OSCL_FastString::set(chartype* cp, uint32 maxlen)
{
    //set string to new writable buffer.
    //make sure buffer is null-terminated
    for (uint32 i = 0; i <= maxlen; i++)
    {
        if (cp[i] == '\0')
        {
            rep.set_w(cp, i, maxlen);
            return;
        }
    }
    OsclError::Leave(OsclErrGeneral);//not null-terminated
}

OSCL_EXPORT_REF void OSCL_wFastString::set(chartype* cp, uint32 maxlen)
{
    //set string to new writable buffer.
    //make sure buffer is null-terminated
    for (uint32 i = 0; i <= maxlen; i++)
    {
        if (cp[i] == '\0')
        {
            rep.set_w(cp, i, maxlen);
            return;
        }
    }
    OsclError::Leave(OsclErrGeneral);//not null-terminated
}

// **************************************************************
OSCL_EXPORT_REF OSCL_FastString::OSCL_FastString(chartype* cp, uint32 maxlen)
{
    set(cp, maxlen);
}

OSCL_EXPORT_REF OSCL_wFastString::OSCL_wFastString(chartype* cp, uint32 maxlen)
{
    set(cp, maxlen);
}

// **************************************************************
OSCL_EXPORT_REF OSCL_FastString::OSCL_FastString(const OSCL_FastString& src) : OSCL_String(src)
{
    set_rep(src);
}

OSCL_EXPORT_REF OSCL_wFastString::OSCL_wFastString(const OSCL_wFastString& src) : OSCL_wString(src)
{
    set_rep(src);
}

// **************************************************************
OSCL_EXPORT_REF OSCL_FastString::~OSCL_FastString()
{
}

OSCL_EXPORT_REF OSCL_wFastString::~OSCL_wFastString()
{
}

// **************************************************************
OSCL_EXPORT_REF void OSCL_FastString::set_length()
{
    rep.size = oscl_strlen(get_cstr());
    //for read-only string, the maxsize tracks the size.
    if (!rep.writable)
        rep.maxsize = rep.size;
}

OSCL_EXPORT_REF void OSCL_wFastString::set_length()
{
    rep.size = oscl_strlen(get_cstr());
    //for read-only string, the maxsize tracks the size.
    if (!rep.writable)
        rep.maxsize = rep.size;
}

// **************************************************************
OSCL_EXPORT_REF OSCL_FastString& OSCL_FastString::operator=(const OSCL_FastString & src)
{
    set_rep(src);
    return (*this);
}

OSCL_EXPORT_REF OSCL_wFastString& OSCL_wFastString::operator=(const OSCL_wFastString & src)
{
    set_rep(src);
    return (*this);
}


// **************************************************************
OSCL_EXPORT_REF OSCL_FastString& OSCL_FastString::operator=(const chartype * cp)
{
    set_rep(cp);
    return (*this);
}

OSCL_EXPORT_REF OSCL_wFastString& OSCL_wFastString::operator=(const chartype * cp)
{
    set_rep(cp);
    return (*this);
}


// **************************************************************
OSCL_EXPORT_REF uint32 OSCL_FastString::get_size() const
{
    return rep.size;
}

OSCL_EXPORT_REF uint32 OSCL_wFastString::get_size() const
{
    return rep.size;
}

// **************************************************************
OSCL_EXPORT_REF uint32 OSCL_FastString::get_maxsize() const
{
    return rep.maxsize;
}

OSCL_EXPORT_REF uint32 OSCL_wFastString::get_maxsize() const
{
    return rep.maxsize;
}

// **************************************************************
OSCL_EXPORT_REF const OSCL_FastString::chartype* OSCL_FastString::get_cstr() const
{
    return (chartype*)rep.buffer;
}

OSCL_EXPORT_REF const OSCL_wFastString::chartype* OSCL_wFastString::get_cstr() const
{
    return (chartype*)rep.buffer;
}

// **************************************************************
OSCL_EXPORT_REF OSCL_FastString::chartype* OSCL_FastString::get_str() const
{
    if (rep.writable)
        return (chartype*)rep.buffer;
    return NULL;
}

OSCL_EXPORT_REF OSCL_wFastString::chartype* OSCL_wFastString::get_str() const
{
    if (rep.writable)
        return (chartype*)rep.buffer;
    return NULL;
}