---

String

/*
 * NOTE: "zlib/libpng" style License
 *
 *                 ----=== s t d n e t ===----
 *
 * Copyright (c) 2002 Warwick Molloy   w-molloy@users.sf.net
 *
 * Copyright (c) 2002 Stdnet Community
 * HTTP://Sourceforge.net/projects/stdnet
 *
 * All references to "software" refer to the stdnet.
 *
 * This software is provided 'as-is', without any express or
 * implied warranty. In no event will the authors be held liable
 * for any damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it
 * and redistribute it freely, subject to the following
 * restrictions:
 *
 * 1.  The origin of this software must not be misrepresented;
 *     you must not claim that you wrote the original software.
 *     If you use this software in a product, an acknowledgment
 *     in the product documentation would be appreciated but
 *     is not required.
 *
 * 2.  Altered source versions must be plainly marked as such,
 *     and must not be misrepresented as being the original
 *     software.
 *
 * 3.  This notice may not be removed or altered from any source
 *     distribution.
 */

#ifndef __system_Class__
#define __system_Class__

#include <stdnet/config.h>
#include <stdnet/system/Object>
#include <stdnet/system/_TakeOwnership>

namespace stdbase {
    namespace system {

class String : public Object
{
private:
    char *  string_val;
    int     string_len;

protected:
    String( const char s[] );

    String( char * const s, _TakeOwnership);

    String(
        const char s[],
        const int len
    );

    String(
        char * const s,
        const int len,
        _TakeOwnership o
    );

    virtual ~String();

public:
    virtual bool
        equals( ObjectRef obj) const;

    static reference< String >
        create( const char val[] );

    static reference< String >
        create( const char val[], const int len );

    static reference< String >
        create( char * const val, _TakeOwnership);

    static reference< String >
        create(
            char * const val,
            const int len,
            _TakeOwnership
        );

    virtual int
        length() const;

    virtual void
        getChars(
            int     srcBegin,
            int     srcEnd,
            char    dst[],
            int     dstBegin
        ) const;
};

//typedef reference<String>   StringRef;
class StringRef : public reference< String >
{
public:
    StringRef( String * p)
        : reference<String>( p )
    {};

    StringRef( Object * p)
        : reference<String>( p )
    {};

    StringRef( const StringRef & r)
        : reference<String>( r )
    {};

    StringRef( const ObjectRef & r)
        : reference<String>( r )
    {};

    StringRef( const reference<String> & r)
        : reference<String>( r )
    {};

    StringRef( const char text[] )
        : reference<String>( String::create( text ) )
    {};

    ~StringRef()
    {};

    StringRef
    operator + (
            const StringRef & b
        ) const;

    StringRef
    operator + (
            const char        b[]
        ) const;

    StringRef
    operator + (
            const int  b_int
        ) const;

};

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


//  -- Globally accessible operators --
//

// ---- Operators in reverse direction -----

inline stdbase::system::StringRef
operator + (
        const int                   b_int,
        stdbase::system::StringRef  a
    )
{   return  a.operator+ (b_int); }

inline stdbase::system::StringRef
operator + (
        const char                  b[],
        stdbase::system::StringRef  a
    )
{   return a.operator +(b);  }



#endif      //  __system_Class__

---