2 Copyright (C) 2001-2006, William Joseph.
5 This file is part of GtkRadiant.
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 #if !defined( INCLUDED_STRING_STRING_H )
23 #define INCLUDED_STRING_STRING_H
25 #include "globaldefs.h"
28 /// C-style null-terminated-character-array string library.
34 #include "memory/allocator.h"
35 #include "generic/arrayrange.h"
37 /// \brief Returns true if \p string length is zero.
39 inline bool string_empty( const char* string ){
40 return *string == '\0';
43 /// \brief Returns true if \p string length is not zero.
45 inline bool string_not_empty( const char* string ){
46 return !string_empty( string );
49 /// \brief Returns <0 if \p string is lexicographically less than \p other.
50 /// Returns >0 if \p string is lexicographically greater than \p other.
51 /// Returns 0 if \p string is lexicographically equal to \p other.
53 inline int string_compare( const char* string, const char* other ){
54 return std::strcmp( string, other );
57 /// \brief Returns true if \p string is lexicographically equal to \p other.
59 inline bool string_equal( const char* string, const char* other ){
60 return string_compare( string, other ) == 0;
63 /// \brief Returns true if [\p string, \p string + \p n) is lexicographically equal to [\p other, \p other + \p n).
65 inline bool string_equal_n( const char* string, const char* other, std::size_t n ){
66 return std::strncmp( string, other, n ) == 0;
69 /// \brief Returns true if \p string is lexicographically less than \p other.
71 inline bool string_less( const char* string, const char* other ){
72 return string_compare( string, other ) < 0;
75 /// \brief Returns true if \p string is lexicographically greater than \p other.
77 inline bool string_greater( const char* string, const char* other ){
78 return string_compare( string, other ) > 0;
81 /// \brief Returns <0 if \p string is lexicographically less than \p other after converting both to lower-case.
82 /// Returns >0 if \p string is lexicographically greater than \p other after converting both to lower-case.
83 /// Returns 0 if \p string is lexicographically equal to \p other after converting both to lower-case.
85 inline int string_compare_nocase( const char* string, const char* other ){
87 return _stricmp( string, other );
89 return strcasecmp( string, other );
93 /// \brief Returns <0 if [\p string, \p string + \p n) is lexicographically less than [\p other, \p other + \p n).
94 /// Returns >0 if [\p string, \p string + \p n) is lexicographically greater than [\p other, \p other + \p n).
95 /// Returns 0 if [\p string, \p string + \p n) is lexicographically equal to [\p other, \p other + \p n).
96 /// Treats all ascii characters as lower-case during comparisons.
98 inline int string_compare_nocase_n( const char* string, const char* other, std::size_t n ){
100 return _strnicmp( string, other, n );
102 return strncasecmp( string, other, n );
106 /// \brief Returns true if \p string is lexicographically equal to \p other.
107 /// Treats all ascii characters as lower-case during comparisons.
109 inline bool string_equal_nocase( const char* string, const char* other ){
110 return string_compare_nocase( string, other ) == 0;
113 /// \brief Returns true if [\p string, \p string + \p n) is lexicographically equal to [\p other, \p other + \p n).
114 /// Treats all ascii characters as lower-case during comparisons.
116 inline bool string_equal_nocase_n( const char* string, const char* other, std::size_t n ){
117 return string_compare_nocase_n( string, other, n ) == 0;
120 /// \brief Returns true if \p string is lexicographically less than \p other.
121 /// Treats all ascii characters as lower-case during comparisons.
123 inline bool string_less_nocase( const char* string, const char* other ){
124 return string_compare_nocase( string, other ) < 0;
127 /// \brief Returns true if \p string is lexicographically greater than \p other.
128 /// Treats all ascii characters as lower-case during comparisons.
130 inline bool string_greater_nocase( const char* string, const char* other ){
131 return string_compare_nocase( string, other ) > 0;
134 /// \brief Returns the number of non-null characters in \p string.
136 inline std::size_t string_length( const char* string ){
137 return std::strlen( string );
140 /// \brief Returns true if the beginning of \p string is equal to \p prefix.
142 inline bool string_equal_prefix( const char* string, const char* prefix ){
143 return string_equal_n( string, prefix, string_length( prefix ) );
146 /// \brief Returns true if the ending of \p string is equal to \p suffix.
148 inline bool string_equal_suffix( const char* string, const char* suffix){
149 const char *s = string + string_length( string ) - string_length( suffix );
150 return string_equal_n( s , suffix, string_length( suffix ) );
153 /// \brief Copies \p other into \p string and returns \p string.
154 /// Assumes that the space allocated for \p string is at least string_length(other) + 1.
156 inline char* string_copy( char* string, const char* other ){
157 return std::strcpy( string, other );
160 /// \brief Allocates a string buffer large enough to hold \p length characters, using \p allocator.
161 /// The returned buffer must be released with \c string_release using a matching \p allocator.
162 template<typename Allocator>
163 inline char* string_new( std::size_t length, Allocator& allocator ){
164 return allocator.allocate( length + 1 );
167 /// \brief Deallocates the \p buffer large enough to hold \p length characters, using \p allocator.
168 template<typename Allocator>
169 inline void string_release( char* buffer, std::size_t length, Allocator& allocator ){
170 allocator.deallocate( buffer, length + 1 );
173 /// \brief Returns a newly-allocated string which is a clone of \p other, using \p allocator.
174 /// The returned buffer must be released with \c string_release using a matching \p allocator.
175 template<typename Allocator>
176 inline char* string_clone( const char* other, Allocator& allocator ){
177 char* copied = string_new( string_length( other ), allocator );
178 std::strcpy( copied, other );
182 /// \brief Returns a newly-allocated string which is a clone of [\p first, \p last), using \p allocator.
183 /// The returned buffer must be released with \c string_release using a matching \p allocator.
184 template<typename Allocator>
185 inline char* string_clone_range( StringRange range, Allocator& allocator ){
186 std::size_t length = range.last - range.first;
187 char* copied = strncpy( string_new( length, allocator ), range.first, length );
188 copied[length] = '\0';
192 /// \brief Allocates a string buffer large enough to hold \p length characters.
193 /// The returned buffer must be released with \c string_release.
194 inline char* string_new( std::size_t length ){
195 DefaultAllocator<char> allocator;
196 return string_new( length, allocator );
199 /// \brief Allocates a new buffer large enough to hold two concatenated strings and fills it with strings.
200 inline char* string_new_concat( const char* a, const char* b ){
201 char* str = string_new( string_length( a ) + string_length( b ) );
207 /// \brief Deallocates the \p buffer large enough to hold \p length characters.
208 inline void string_release( char* string, std::size_t length ){
209 DefaultAllocator<char> allocator;
210 string_release( string, length, allocator );
213 /// \brief Returns a newly-allocated string which is a clone of \p other.
214 /// The returned buffer must be released with \c string_release.
215 inline char* string_clone( const char* other ){
216 DefaultAllocator<char> allocator;
217 return string_clone( other, allocator );
220 /// \brief Returns a newly-allocated string which is a clone of [\p first, \p last).
221 /// The returned buffer must be released with \c string_release.
222 inline char* string_clone_range( StringRange range ){
223 DefaultAllocator<char> allocator;
224 return string_clone_range( range, allocator );
227 typedef char* char_pointer;
228 /// \brief Swaps the values of \p string and \p other.
229 inline void string_swap( char_pointer& string, char_pointer& other ){
230 std::swap( string, other );
233 typedef const char* char_const_pointer;
234 /// \brief Swaps the values of \p string and \p other.
235 inline void string_swap( char_const_pointer& string, char_const_pointer& other ){
236 std::swap( string, other );
239 /// \brief Converts each character of \p string to lower-case and returns \p string.
241 inline char* string_to_lowercase( char* string ){
242 for ( char* p = string; *p != '\0'; ++p )
244 *p = (char)std::tolower( *p );
249 /// \brief Converts each character of \p string to upper-case and returns \p string.
251 inline char* string_to_uppercase( char* string ){
252 for ( char* p = string; *p != '\0'; ++p )
254 *p = (char)std::toupper( *p );
259 /// \brief A re-entrant string tokeniser similar to strchr.
260 class StringTokeniser
262 bool istoken( char c ) const {
263 if ( strchr( m_delimiters, c ) != 0 ) {
268 const char* advance(){
269 const char* token = m_pos;
271 while ( !string_empty( m_pos ) )
273 if ( !istoken( *m_pos ) ) {
277 else if ( !intoken ) {
284 std::size_t m_length;
287 const char* m_delimiters;
289 StringTokeniser( const char* string, const char* delimiters = " \n\r\t\v" ) :
290 m_length( string_length( string ) ),
291 m_string( string_copy( string_new( m_length ), string ) ),
293 m_delimiters( delimiters ){
294 while ( !string_empty( m_pos ) && !istoken( *m_pos ) )
300 string_release( m_string, m_length );
302 /// \brief Returns the next token or "" if there are no more tokens available.
303 const char* getToken(){
308 /// \brief A non-mutable c-style string.
310 /// \param Buffer The string storage implementation. Must be DefaultConstructible, CopyConstructible and Assignable. Must implement:
311 /// \li Buffer(const char* string) - constructor which copies a c-style \p string.
312 /// \li Buffer(const char* first, const char*) - constructor which copies a c-style string range [\p first, \p last).
313 /// \li void swap(Buffer& other) - swaps contents with \p other.
314 /// \li const char* c_str() - returns the stored non-mutable c-style string.
315 template<typename Buffer>
316 class String : public Buffer
323 String( const char* string )
326 String( StringRange range )
330 String& operator=( const String& other ){
331 String temp( other );
335 String& operator=( const char* string ){
336 String temp( string );
340 String& operator=( StringRange range ){
341 String temp( range );
346 void swap( String& other ){
347 Buffer::swap( other );
351 return string_empty( Buffer::c_str() );
355 template<typename Buffer>
356 inline bool operator<( const String<Buffer>& self, const String<Buffer>& other ){
357 return string_less( self.c_str(), other.c_str() );
360 template<typename Buffer>
361 inline bool operator>( const String<Buffer>& self, const String<Buffer>& other ){
362 return string_greater( self.c_str(), other.c_str() );
365 template<typename Buffer>
366 inline bool operator==( const String<Buffer>& self, const String<Buffer>& other ){
367 return string_equal( self.c_str(), other.c_str() );
370 template<typename Buffer>
371 inline bool operator!=( const String<Buffer>& self, const String<Buffer>& other ){
372 return !string_equal( self.c_str(), other.c_str() );
375 template<typename Buffer>
376 inline bool operator==( const String<Buffer>& self, const char* other ){
377 return string_equal( self.c_str(), other );
380 template<typename Buffer>
381 inline bool operator!=( const String<Buffer>& self, const char* other ){
382 return !string_equal( self.c_str(), other );
387 /// \brief Swaps the values of \p self and \p other.
388 /// Overloads std::swap.
389 template<typename Buffer>
390 inline void swap( String<Buffer>& self, String<Buffer>& other ){
396 /// \brief A non-mutable string buffer which manages memory allocation.
397 template<typename Allocator>
398 class CopiedBuffer : private Allocator
402 char* copy_range( StringRange range ){
403 return string_clone_range( range, static_cast<Allocator&>( *this ) );
405 char* copy( const char* other ){
406 return string_clone( other, static_cast<Allocator&>( *this ) );
408 void destroy( char* string ){
409 string_release( string, string_length( string ), static_cast<Allocator&>( *this ) );
418 : m_string( copy( "" ) ){
420 explicit CopiedBuffer( const Allocator& allocator )
421 : Allocator( allocator ), m_string( copy( "" ) ){
423 CopiedBuffer( const CopiedBuffer& other )
424 : Allocator( other ), m_string( copy( other.m_string ) ){
426 CopiedBuffer( const char* string, const Allocator& allocator = Allocator() )
427 : Allocator( allocator ), m_string( copy( string ) ){
429 CopiedBuffer( StringRange range, const Allocator& allocator = Allocator() )
430 : Allocator( allocator ), m_string( copy_range( range ) ){
432 const char* c_str() const {
435 void swap( CopiedBuffer& other ){
436 string_swap( m_string, other.m_string );
440 /// \brief A non-mutable string which uses copy-by-value for assignment.
441 typedef String< CopiedBuffer< DefaultAllocator<char> > > CopiedString;
444 /// \brief A non-mutable string buffer which uses reference-counting to avoid unnecessary allocations.
445 template<typename Allocator>
446 class SmartBuffer : private Allocator
450 char* copy_range( StringRange range ){
451 char* buffer = Allocator::allocate( sizeof( std::size_t ) + ( range.last - range.first ) + 1 );
452 strncpy( buffer + sizeof( std::size_t ), range.first, range.last - range.first );
453 buffer[sizeof( std::size_t ) + ( range.last - range.first )] = '\0';
454 *reinterpret_cast<std::size_t*>( buffer ) = 0;
457 char* copy( const char* string ){
458 char* buffer = Allocator::allocate( sizeof( std::size_t ) + string_length( string ) + 1 );
459 strcpy( buffer + sizeof( std::size_t ), string );
460 *reinterpret_cast<std::size_t*>( buffer ) = 0;
463 void destroy( char* buffer ){
464 Allocator::deallocate( buffer, sizeof( std::size_t ) + string_length( c_str() ) + 1 );
467 void incref( char* buffer ){
468 ++( *reinterpret_cast<std::size_t*>( buffer ) );
470 void decref( char* buffer ){
471 if ( --( *reinterpret_cast<std::size_t*>( buffer ) ) == 0 ) {
482 : m_buffer( copy( "" ) ){
485 explicit SmartBuffer( const Allocator& allocator )
486 : Allocator( allocator ), m_buffer( copy( "" ) ){
489 SmartBuffer( const SmartBuffer& other )
490 : Allocator( other ), m_buffer( other.m_buffer ){
493 SmartBuffer( const char* string, const Allocator& allocator = Allocator() )
494 : Allocator( allocator ), m_buffer( copy( string ) ){
497 SmartBuffer( StringRange range, const Allocator& allocator = Allocator() )
498 : Allocator( allocator ), m_buffer( copy_range( range ) ){
501 const char* c_str() const {
502 return m_buffer + sizeof( std::size_t );
504 void swap( SmartBuffer& other ){
505 string_swap( m_buffer, other.m_buffer );
509 /// \brief A non-mutable string which uses copy-by-reference for assignment of SmartString.
510 typedef String< SmartBuffer< DefaultAllocator<char> > > SmartString;
512 class StringEqualNoCase
515 bool operator()( const CopiedString& key, const CopiedString& other ) const {
516 return string_equal_nocase( key.c_str(), other.c_str() );
520 struct StringLessNoCase
522 bool operator()( const CopiedString& x, const CopiedString& y ) const {
523 return string_less_nocase( x.c_str(), y.c_str() );
527 struct RawStringEqual
529 bool operator()( const char* x, const char* y ) const {
530 return string_equal( x, y );
536 bool operator()( const char* x, const char* y ) const {
537 return string_less( x, y );
541 struct RawStringLessNoCase
543 bool operator()( const char* x, const char* y ) const {
544 return string_less_nocase( x, y );