20 #ifndef _RTL_STRING_HXX_
21 #define _RTL_STRING_HXX_
34 #ifdef RTL_FAST_STRING
40 #if !defined EXCEPTIONS_OFF
49 #ifdef RTL_STRING_UNITTEST
50 #define rtl rtlunittest
56 #ifdef RTL_STRING_UNITTEST
59 #define RTL_STRING_CONST_FUNCTION rtl_string_unittest_const_literal_function = true;
61 #define RTL_STRING_CONST_FUNCTION
168 #ifdef HAVE_SFINAE_ANONYMOUS_BROKEN
179 template<
typename T >
186 template<
typename T >
203 template<
typename T >
209 #ifdef RTL_STRING_UNITTEST
210 rtl_string_unittest_const_literal =
true;
214 #endif // HAVE_SFINAE_ANONYMOUS_BROKEN
251 #if defined EXCEPTIONS_OFF
254 throw std::bad_alloc();
259 #ifdef RTL_FAST_STRING
260 template<
typename T1,
typename T2 >
261 OString(
const OStringConcat< T1, T2 >& c )
263 const sal_Int32 l = c.length();
264 rtl_String* buffer = NULL;
268 char* end = c.addData( buffer->buffer );
269 buffer->length = end - buffer->buffer;
299 template<
typename T >
339 return pData->length == 0;
364 sal_Char operator [](sal_Int32 index)
const {
return getStr()[index]; }
381 str.pData->buffer, str.pData->length );
400 rObj.pData->buffer, rObj.pData->length, maxLength );
418 str.pData->buffer, str.pData->length );
434 if ( pData->length != str.pData->length )
436 if ( pData == str.pData )
439 str.pData->buffer, str.pData->length ) == 0;
459 if ( pData->length != length )
463 value, length ) == 0;
482 if ( pData->length != str.pData->length )
484 if ( pData == str.pData )
487 str.pData->buffer, str.pData->length ) == 0;
511 #ifdef HAVE_SFINAE_ANONYMOUS_BROKEN
517 template<
typename T >
523 template<
typename T >
534 template<
typename T >
567 if ( pData->length != asciiStrLength )
571 asciiStr, asciiStrLength ) == 0;
592 str.pData->buffer, str.pData->length, str.pData->length ) == 0;
600 template<
typename T >
606 pData->buffer + fromIndex, pData->length - fromIndex,
627 char const * str, sal_Int32 strLength, sal_Int32 fromIndex = 0)
631 pData->buffer + fromIndex, pData->length - fromIndex,
632 str, strLength, strLength) == 0;
639 #if SAL_TYPES_SIZEOFLONG == 8
664 str.pData->buffer, str.pData->length,
665 str.pData->length ) == 0;
673 template<
typename T >
693 return match(str, 0);
701 template<
typename T >
705 return match(literal, 0);
720 && match(str, getLength() - str.
getLength());
728 template<
typename T >
750 bool endsWithL(
char const * str, sal_Int32 strLength)
const {
751 return strLength <= getLength()
752 && matchL(str, strLength, getLength() - strLength);
756 {
return rStr1.equals(rStr2); }
760 {
return rStr1.compareTo( rStr2 ) < 0; }
762 {
return rStr1.compareTo( rStr2 ) > 0; }
764 {
return rStr1.compareTo( rStr2 ) <= 0; }
766 {
return rStr1.compareTo( rStr2 ) >= 0; }
768 template<
typename T >
771 return rStr1.compareTo( value ) == 0;
774 template<
typename T >
777 return rStr1.compareTo( value ) == 0;
780 template<
typename T >
783 return rStr2.compareTo( value ) == 0;
786 template<
typename T >
789 return rStr2.compareTo( value ) == 0;
797 template<
typename T >
812 template<
typename T >
822 template<
typename T >
828 template<
typename T >
834 template<
typename T >
840 template<
typename T >
851 template<
typename T >
854 return !( rStr == literal );
862 template<
typename T >
865 return !( literal == rStr );
896 return (ret < 0 ? ret : ret+fromIndex);
948 str.pData->buffer, str.pData->length );
949 return (ret < 0 ? ret : ret+fromIndex);
957 template<
typename T >
964 return n < 0 ? n : n + fromIndex;
985 sal_Int32 indexOfL(
char const * str, sal_Int32 len, sal_Int32 fromIndex = 0)
989 pData->buffer + fromIndex, pData->length - fromIndex, str, len);
990 return n < 0 ? n : n + fromIndex;
997 #if SAL_TYPES_SIZEOFLONG == 8
1019 str.pData->buffer, str.pData->length );
1042 str.pData->buffer, str.pData->length );
1057 rtl_String *pNew = 0;
1059 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1076 rtl_String *pNew = 0;
1078 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1091 rtl_String* pNew = 0;
1093 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1096 #ifndef RTL_FAST_STRING
1099 return str1.concat( str2 );
1118 rtl_String* pNew = 0;
1120 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1138 rtl_String* pNew = 0;
1140 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1162 OString const & from,
OString const & to, sal_Int32 * index = 0)
const
1167 &s, pData, from.pData->buffer, from.pData->length,
1168 to.pData->buffer, to.pData->length, index == 0 ? &i : index);
1188 &s, pData, from.pData->buffer, from.pData->length,
1189 to.pData->buffer, to.pData->length);
1205 rtl_String* pNew = 0;
1207 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1222 rtl_String* pNew = 0;
1224 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1240 rtl_String* pNew = 0;
1242 return OString( pNew, (DO_NOT_ACQUIRE*)0 );
1271 rtl_String * pNew = 0;
1273 return OString( pNew, (DO_NOT_ACQUIRE *)0 );
1291 return getToken(count, separator, n);
1315 return pData->buffer[0];
1327 sal_Int32 toInt32( sal_Int16 radix = 10 ) const
SAL_THROW(())
1341 sal_Int64 toInt64( sal_Int16 radix = 10 ) const
SAL_THROW(())
1385 rtl_String* pNewData = 0;
1387 return OString( pNewData, (DO_NOT_ACQUIRE*)0 );
1413 rtl_String* pNewData = 0;
1415 return OString( pNewData, (DO_NOT_ACQUIRE*)0 );
1430 rtl_String* pNewData = 0;
1432 return OString( pNewData, (DO_NOT_ACQUIRE*)0 );
1446 rtl_String* pNewData = 0;
1448 return OString( pNewData, (DO_NOT_ACQUIRE*)0 );
1462 rtl_String* pNewData = 0;
1464 return OString( pNewData, (DO_NOT_ACQUIRE*)0 );
1470 #ifdef RTL_FAST_STRING
1482 OStringLiteral(
const char (&str)[ N ] ) : size( N - 1 ), data( str ) { assert( strlen( str ) == N - 1 ); }
1488 struct ToStringHelper< OString >
1490 static int length(
const OString& s ) {
return s.getLength(); }
1491 static char* addData(
char* buffer,
const OString& s ) {
return addDataHelper( buffer, s.getStr(), s.getLength()); }
1492 static const bool allowOStringConcat =
true;
1493 static const bool allowOUStringConcat =
false;
1499 static int length(
const OStringLiteral& str ) {
return str.size; }
1500 static char* addData(
char* buffer,
const OStringLiteral& str ) {
return addDataHelper( buffer, str.data, str.size ); }
1501 static const bool allowOStringConcat =
true;
1502 static const bool allowOUStringConcat =
false;
1505 template<
typename charT,
typename traits,
typename T1,
typename T2 >
1506 inline std::basic_ostream<charT, traits> &
operator <<(
1507 std::basic_ostream<charT, traits> & stream,
const OStringConcat< T1, T2 >& concat)
1509 return stream << OString( concat );
1518 #ifdef RTL_STRING_UNITTEST
1521 typedef rtlunittest::OString OString;
1523 #undef RTL_STRING_CONST_FUNCTION
1546 {
return (
size_t)rString.
hashCode(); }
1557 template<
typename charT,
typename traits > std::basic_ostream<charT, traits> &
1559 std::basic_ostream<charT, traits> & stream,
rtl::OString const &
string)
1561 return stream <<
string.getStr();
1568 using ::rtl::OString;
1569 using ::rtl::OStringHash;