---

String.cpp

//  -- stdnet headers --
#include <stdnet/system/String>

//  -- C Headers --
#include <string.h>

namespace stdbase {
    namespace system {


// -- Factory Functions --
//
reference<String> String::
    create( const char val[])
{
    return reference<String>( new String(val) );
}

reference<String> String::
    create( const char val[], const int len)
{
    return reference<String>( new String(val, len) );
}

reference<String> String::
    create( char * const val, _TakeOwnership)
{
    return reference<String>( new String(val, _TakeOwnership() ) );
}

reference<String> String::
    create(
        char * const val,
        const int len,
        _TakeOwnership
    )
{
    return reference<String>( new String(val, len, _TakeOwnership() ) );
}

//  --  Class Methods --
//
String::
    String( const char s[])
        :   Object(),
            string_val( 0 ),
            string_len( strlen(s) )
{
    string_val = new char[ string_len ];
    strncpy( string_val, s, string_len );
}

String::
    String( const char s[], const int len)
        :   Object(),
            string_val( new char[ len ] ),
            string_len( len )
{   strncpy( string_val, s, len ); }

String::
    String( char * const s, _TakeOwnership)
        :   Object(),
            string_val( s ),
            string_len( strlen(s) )
{};

String::
    String( char * const s, const int len, _TakeOwnership o)
        :   Object(),
            string_val( s ),
            string_len( len )
{};

String::
    ~String()
{
    delete [] string_val;
    string_val = 0;
    string_len = 0;
}

bool String::
    equals( ObjectRef obj) const
{
    return const_cast< const Object *>( obj.get() ) == this;
}

int String::
    length() const
{   return string_len; }

void String::
    getChars(
        int     srcBegin,
        int     srcEnd,
        char    dst[],
        int     dstBegin
    ) const
{
    int srcLen = srcEnd - srcBegin;

    strncpy(
        & dst[ dstBegin ],
        & string_val[ srcBegin ],
        srcLen
    );
}


StringRef   StringRef::
operator + (
        // this ptr is implicit 'a'
        const StringRef & b
    ) const
{
    const StringRef & a = *this;
    int a_len = a->length();
    int b_len = b->length();
    const int len = a_len + b_len;  // + 1;

    char * store = new char[ len ];

    a->getChars( 0, a_len, store, 0);
    b->getChars( 0, b_len, store, a_len);
    store[len] = 0;

    StringRef str = String::
                create(
                    (char * const) store,
                    len,
                    _TakeOwnership()
                );

    //  -- PLEASE NOTE --
    //  I have not deleted the store variable deliberately!
    //  The _TakeOwnership argument flags to the String object
    //  that the store pointer must be managed by it.
    //
    return str;
}

StringRef StringRef::
operator + (
        //  this is implicit a
        const char        b[]
    ) const
{
    const StringRef & a = *this;
    int a_len = a->length();
    int b_len = strlen( b );
    const int len = a_len + b_len; // + 1;

    char * store = new char[ len + 1];

    a->getChars( 0, a_len, store, 0);
    strncpy( & store[ a_len ], b, b_len );
    store[len] = 0;

    StringRef str = String::
                create(
                    (char * const) store,
                    len,
                    _TakeOwnership()
                );

    //  -- PLEASE NOTE --
    //  I have not deleted the store variable deliberately!
    //  The _TakeOwnership argument flags to the String object
    //  that the store pointer must be managed by it.
    //
    return str;
}

StringRef StringRef::
operator + (
        //  this is operand a
        const int         b_int
    ) const
{
    const StringRef & a = *this;
    int a_len = a->length();

    //  max length of a 64-bit int
    //  we'll use this as a speculative length for b
    //  so we can do the string operation once only.
    //
    const int b_max = 22;
    int b_len = b_max;
    
    int len = a_len + b_max + 1;

    char * store = new char[ len ];

    a->getChars( 0, a_len, store, 0);
    b_len = snprintf( & store[ a_len ], b_max, "%d", b_int );
    
    len = a_len + b_len + 1;
    store[len] = 0;

    StringRef str = String::
                create(
                    (char * const) store,
                    len,
                    _TakeOwnership()
                );

    //  -- PLEASE NOTE --
    //  I have not deleted the store variable deliberately!
    //  The _TakeOwnership argument flags to the String object
    //  that the store pointer must be managed by it.
    //
    return str;
}


    } // -- end namespace system --
} // ------ end namespace stdbase --

//  -- Globally accessible operators --
//

---