stringinline.h

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#ifndef _Pegasus_StringInline_h
#define _Pegasus_StringInline_h

#include <Pegasus/Common/StringRep.h>
#include <cstring>

#ifdef PEGASUS_INTERNALONLY
# define PEGASUS_STRING_INLINE inline
#else
# define PEGASUS_STRING_INLINE /* empty */
#endif

PEGASUS_NAMESPACE_BEGIN

PEGASUS_STRING_INLINE CString::CString() : _rep(0)
{
}

PEGASUS_STRING_INLINE CString::CString(char* cstr) : _rep(cstr)
{
}

PEGASUS_STRING_INLINE CString::~CString()
{
    operator delete(_rep);
}

PEGASUS_STRING_INLINE CString::operator const char*() const
{
    return _rep;
}

PEGASUS_STRING_INLINE String::String()
{
    // Note: ref() and unref() never touch the reference count of _emptyRep.
    // This allows use to optimize the copy constructor by not incrementing
    // _emptyRep.refs here. Performance is critical in this function. Please
    // do not add any code to this function.
    _rep = &StringRep::_emptyRep;
}

PEGASUS_STRING_INLINE String::String(const String& str)
{
#ifdef PEGASUS_HAVE_BROKEN_GLOBAL_CONSTRUCTION
    //
    // Some compilers don't do a good job of initializing global
    //   constructors in the proper sequence.  This is one such case.
    // String::EMPTY is not initialized by the time this is first
    //   called during initialization of the executable.
    //
    if (!str._rep)
    {
      _rep = &StringRep::_emptyRep;
      return;
    }
#endif
    StringRep::ref(_rep = str._rep);
}

PEGASUS_STRING_INLINE String::~String()
{
    StringRep::unref(_rep);
}

PEGASUS_STRING_INLINE Uint32 String::size() const
{
    return _rep->size;
}

PEGASUS_STRING_INLINE const Char16* String::getChar16Data() const
{
    return (Char16*)&(_rep->data[0]);
}

PEGASUS_STRING_INLINE Char16& String::operator[](Uint32 i)
{
    _checkBounds(i, _rep->size);

    if (_rep->refs.get() != 1)
        _rep = StringRep::copyOnWrite(_rep);

    return (Char16&)_rep->data[i];
}

PEGASUS_STRING_INLINE const Char16 String::operator[](Uint32 i) const
{
    _checkBounds(i, _rep->size);
    return (Char16&)_rep->data[i];
}

PEGASUS_STRING_INLINE String& String::operator=(const String& str)
{
    return assign(str);
}

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
PEGASUS_STRING_INLINE String& String::operator=(const char* str)
{
    return assign(str);
}
#endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */

PEGASUS_STRING_INLINE String& String::assign(const Char16* str)
{
    return assign(str, StringRep::length((Uint16*)str));
}

PEGASUS_STRING_INLINE String& String::assign(const char* str)
{
    return assign(str, strlen(str));
}

PEGASUS_STRING_INLINE Uint32 String::find(const String& s) const
{
    return StringFindAux(_rep, (Char16*)&(s._rep->data[0]), s._rep->size);
}

PEGASUS_STRING_INLINE String& String::append(const Char16& c)
{
    if (_rep->size == _rep->cap || _rep->refs.get() != 1)
        StringAppendCharAux(_rep);

    _rep->data[_rep->size++] = c;
    _rep->data[_rep->size] = 0;
    return *this;
}

PEGASUS_STRING_INLINE Boolean String::equalNoCase(
    const String& s1, const String& s2)
{
#ifdef PEGASUS_HAS_ICU
    return StringEqualNoCase(s1, s2);
#else
    return s1._rep->size == s2._rep->size && StringEqualNoCase(s1, s2);
#endif
}

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
PEGASUS_STRING_INLINE String& String::append(const char* str)
{
    append(str, strlen(str));
    return *this;
}
#endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */

PEGASUS_STRING_INLINE Boolean operator==(const String& s1, const String& s2)
{
    return String::equal(s1, s2);
}

PEGASUS_STRING_INLINE Boolean operator==(const String& s1, const char* s2)
{
    return String::equal(s1, s2);
}

PEGASUS_STRING_INLINE Boolean operator==(const char* s1, const String& s2)
{
    return String::equal(s2, s1);
}

PEGASUS_STRING_INLINE Boolean operator!=(const String& s1, const String& s2)
{
    return !String::equal(s1, s2);
}

PEGASUS_STRING_INLINE Boolean operator!=(const String& s1, const char* s2)
{
    return !String::equal(s1, s2);
}

PEGASUS_STRING_INLINE Boolean operator!=(const char* s1, const String& s2)
{
    return !String::equal(s2, s1);
}

PEGASUS_STRING_INLINE Boolean operator<(const String& s1, const String& s2)
{
    return String::compare(s1, s2) < 0;
}

PEGASUS_STRING_INLINE Boolean operator<(const String& s1, const char* s2)
{
    return String::compare(s1, s2) < 0;
}

PEGASUS_STRING_INLINE Boolean operator<(const char* s1, const String& s2)
{
    return String::compare(s2, s1) > 0;
}

PEGASUS_STRING_INLINE Boolean operator>(const String& s1, const String& s2)
{
    return String::compare(s1, s2) > 0;
}

PEGASUS_STRING_INLINE Boolean operator>(const String& s1, const char* s2)
{
    return String::compare(s1, s2) > 0;
}

PEGASUS_STRING_INLINE Boolean operator>(const char* s1, const String& s2)
{
    return String::compare(s2, s1) < 0;
}

PEGASUS_STRING_INLINE Boolean operator<=(const String& s1, const String& s2)
{
    return String::compare(s1, s2) <= 0;
}

PEGASUS_STRING_INLINE Boolean operator<=(const String& s1, const char* s2)
{
    return String::compare(s1, s2) <= 0;
}

PEGASUS_STRING_INLINE Boolean operator<=(const char* s1, const String& s2)
{
    return String::compare(s2, s1) >= 0;
}

PEGASUS_STRING_INLINE Boolean operator>=(const String& s1, const String& s2)
{
    return String::compare(s1, s2) >= 0;
}

PEGASUS_STRING_INLINE Boolean operator>=(const String& s1, const char* s2)
{
    return String::compare(s1, s2) >= 0;
}

PEGASUS_STRING_INLINE Boolean operator>=(const char* s1, const String& s2)
{
    return String::compare(s2, s1) <= 0;
}

PEGASUS_STRING_INLINE String operator+(const String& s1, const String& s2)
{
#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
    return String(s1, s2);
#else
    String tmp;
    tmp.reserveCapacity(s1.size() + s2.size());
    tmp.append(s1);
    tmp.append(s2);
    return tmp;
#endif
}

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
PEGASUS_STRING_INLINE String operator+(const String& s1, const char* s2)
{
    return String(s1, s2);
}
#endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */

#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
PEGASUS_STRING_INLINE String operator+(const char* s1, const String& s2)
{
    return String(s1, s2);
}
#endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */

PEGASUS_NAMESPACE_END

#endif /* _Pegasus_StringInline_h */