20 #ifndef INCLUDED_RTL_STRING_HXX
21 #define INCLUDED_RTL_STRING_HXX
34 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
45 #ifdef RTL_STRING_UNITTEST
46 #define rtl rtlunittest
53 #ifdef RTL_STRING_UNITTEST
56 #define RTL_STRING_CONST_FUNCTION rtl_string_unittest_const_literal_function = true;
58 #define RTL_STRING_CONST_FUNCTION
157 template<
typename T >
164 template<
typename T >
181 template<
typename T >
190 #ifdef RTL_STRING_UNITTEST
191 rtl_string_unittest_const_literal =
true;
230 throw std::bad_alloc();
234 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
239 template<
typename T1,
typename T2 >
240 OString(
const OStringConcat< T1, T2 >& c )
242 const sal_Int32 l = c.length();
246 char* end = c.addData( pData->buffer );
247 pData->length = end - pData->buffer;
277 template<
typename T >
280 RTL_STRING_CONST_FUNCTION
300 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
305 template<
typename T1,
typename T2 >
306 OString& operator+=(
const OStringConcat< T1, T2 >& c )
308 const int l = c.length();
312 char* end = c.addData( pData->buffer + pData->length );
314 pData->length = end - pData->buffer;
348 return pData->length == 0;
375 assert(index >= 0 && static_cast<sal_uInt32>(index) < static_cast<sal_uInt32>(getLength()));
376 return getStr()[index];
394 str.pData->buffer, str.pData->length );
413 rObj.pData->buffer, rObj.pData->length, maxLength );
431 str.pData->buffer, str.pData->length );
447 if ( pData->length != str.pData->length )
449 if ( pData == str.pData )
452 str.pData->buffer, str.pData->length ) == 0;
472 if ( pData->length != length )
476 value, length ) == 0;
495 if ( pData->length != str.pData->length )
497 if ( pData == str.pData )
500 str.pData->buffer, str.pData->length ) == 0;
524 template<
typename T >
530 template<
typename T >
541 template<
typename T >
544 RTL_STRING_CONST_FUNCTION
573 if ( pData->length != asciiStrLength )
577 asciiStr, asciiStrLength ) == 0;
598 str.pData->buffer, str.pData->length, str.pData->length ) == 0;
606 template<
typename T >
609 RTL_STRING_CONST_FUNCTION
612 pData->buffer + fromIndex, pData->length - fromIndex,
633 char const * str, sal_Int32 strLength, sal_Int32 fromIndex = 0)
637 pData->buffer + fromIndex, pData->length - fromIndex,
638 str, strLength, strLength) == 0;
645 #if SAL_TYPES_SIZEOFLONG == 8
670 str.pData->buffer, str.pData->length,
671 str.pData->length ) == 0;
679 template<
typename T >
682 RTL_STRING_CONST_FUNCTION
703 bool b = match(str, 0);
704 if (b && rest != 0) {
715 template<
typename T >
717 T & literal,
OString * rest = 0)
const
719 RTL_STRING_CONST_FUNCTION
720 bool b = match(literal, 0);
721 if (b && rest != 0) {
743 && match(str, getLength() - str.
getLength());
744 if (b && rest != 0) {
745 *rest = copy(0, getLength() - str.
getLength());
755 template<
typename T >
757 T & literal,
OString * rest = 0)
const
759 RTL_STRING_CONST_FUNCTION
763 if (b && rest != 0) {
785 bool endsWithL(
char const * str, sal_Int32 strLength)
const {
786 return strLength <= getLength()
787 && matchL(str, strLength, getLength() - strLength);
791 {
return rStr1.
equals(rStr2); }
799 {
return rStr1.
compareTo( rStr2 ) <= 0; }
801 {
return rStr1.
compareTo( rStr2 ) >= 0; }
803 template<
typename T >
809 template<
typename T >
815 template<
typename T >
821 template<
typename T >
832 template<
typename T >
835 RTL_STRING_CONST_FUNCTION
847 template<
typename T >
850 RTL_STRING_CONST_FUNCTION
857 template<
typename T >
863 template<
typename T >
869 template<
typename T >
875 template<
typename T >
886 template<
typename T >
889 return !( rStr == literal );
897 template<
typename T >
900 return !( literal == rStr );
931 return (ret < 0 ? ret : ret+fromIndex);
983 str.pData->buffer, str.pData->length );
984 return (ret < 0 ? ret : ret+fromIndex);
992 template<
typename T >
995 RTL_STRING_CONST_FUNCTION
999 return n < 0 ? n : n + fromIndex;
1020 sal_Int32
indexOfL(
char const * str, sal_Int32 len, sal_Int32 fromIndex = 0)
1024 pData->buffer + fromIndex, pData->length - fromIndex, str, len);
1025 return n < 0 ? n : n + fromIndex;
1032 #if SAL_TYPES_SIZEOFLONG == 8
1054 str.pData->buffer, str.pData->length );
1077 str.pData->buffer, str.pData->length );
1092 rtl_String *pNew = 0;
1111 rtl_String *pNew = 0;
1126 rtl_String* pNew = 0;
1131 #ifndef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
1134 return str1.
concat( str2 );
1153 rtl_String* pNew = 0;
1173 rtl_String* pNew = 0;
1197 OString const & from,
OString const & to, sal_Int32 * index = 0)
const
1202 &s, pData, from.pData->buffer, from.pData->length,
1203 to.pData->buffer, to.pData->length, index == 0 ? &i : index);
1223 &s, pData, from.pData->buffer, from.pData->length,
1224 to.pData->buffer, to.pData->length);
1240 rtl_String* pNew = 0;
1257 rtl_String* pNew = 0;
1275 rtl_String* pNew = 0;
1306 rtl_String * pNew = 0;
1326 return getToken(count, separator, n);
1350 return pData->buffer[0];
1455 return number( static_cast< long long >( i ), radix );
1461 return number( static_cast< unsigned long long >( i ), radix );
1467 return number( static_cast< long long >( i ), radix );
1473 return number( static_cast< unsigned long long >( i ), radix );
1480 rtl_String* pNewData = 0;
1489 rtl_String* pNewData = 0;
1506 rtl_String* pNewData = 0;
1523 rtl_String* pNewData = 0;
1558 rtl_String* pNewData = 0;
1587 return number( i, radix );
1602 return number( ll, radix );
1637 #ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
1649 explicit OStringLiteral(
const char (&str)[ N ] ) : size( N - 1 ), data( str ) { assert( strlen( str ) == N - 1 ); }
1658 struct ToStringHelper< OString >
1660 static int length(
const OString& s ) {
return s.getLength(); }
1661 static char* addData(
char* buffer,
const OString& s ) {
return addDataHelper( buffer, s.getStr(), s.getLength()); }
1662 static const bool allowOStringConcat =
true;
1663 static const bool allowOUStringConcat =
false;
1670 struct ToStringHelper< OStringLiteral >
1672 static int length(
const OStringLiteral& str ) {
return str.size; }
1673 static char* addData(
char* buffer,
const OStringLiteral& str ) {
return addDataHelper( buffer, str.data, str.size ); }
1674 static const bool allowOStringConcat =
true;
1675 static const bool allowOUStringConcat =
false;
1681 template<
typename charT,
typename traits,
typename T1,
typename T2 >
1682 inline std::basic_ostream<charT, traits> &
operator <<(
1683 std::basic_ostream<charT, traits> & stream,
const OStringConcat< T1, T2 >& concat)
1685 return stream << OString( concat );
1707 {
return (
size_t)rString.
hashCode(); }
1732 template<
typename charT,
typename traits > std::basic_ostream<charT, traits> &
1734 std::basic_ostream<charT, traits> & stream,
OString const &
string)
1736 return stream <<
string.getStr();
1742 #ifdef RTL_STRING_UNITTEST
1745 typedef rtlunittest::OString OString;
1747 #undef RTL_STRING_CONST_FUNCTION
1750 #if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST
1751 using ::rtl::OString;
1752 using ::rtl::OStringHash;
1753 using ::rtl::OStringLiteral;
1756 #endif // INCLUDED_RTL_STRING_HXX