← Back to branch summary

~ubuntu-branches/ubuntu/precise/grantlee/precise

« back to all changes in this revision

Viewing changes to corelib/safestring.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Harald Sitter
  • Date: 2010-06-11 23:41:45 UTC
  • Revision ID: james.westby@ubuntu.com-20100611234145-oas7rhdrbwy8j55c
Tags: upstream-0.1.1
Import upstream version 0.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
corelib/safestring.cpp
 
1
/*
 
2
  This file is part of the Grantlee template system.
 
3
 
 
4
  Copyright (c) 2009,2010 Stephen Kelly <steveire@gmail.com>
 
5
 
 
6
  This library is free software; you can redistribute it and/or
 
7
  modify it under the terms of the GNU Lesser General Public
 
8
  License as published by the Free Software Foundation; either version
 
9
  2 of the Licence, or (at your option) any later version.
 
10
 
 
11
  This library is distributed in the hope that it will be useful,
 
12
  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
  Library General Public License for more details.
 
15
 
 
16
  You should have received a copy of the GNU Lesser General Public
 
17
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
18
 
 
19
*/
 
20
 
 
21
#include "safestring.h"
 
22
 
 
23
#include <QtCore/QStringList>
 
24
 
 
25
using namespace Grantlee;
 
26
 
 
27
SafeString::SafeString()
 
28
  : m_nestedString( this ),
 
29
    m_safety( IsNotSafe ),
 
30
    m_needsescape( false )
 
31
{
 
32
 
 
33
}
 
34
 
 
35
SafeString::SafeString( const Grantlee::SafeString& safeString )
 
36
  : m_nestedString( safeString.get(), this ),
 
37
    m_safety( safeString.m_safety ),
 
38
    m_needsescape( safeString.m_needsescape )
 
39
{
 
40
 
 
41
}
 
42
 
 
43
SafeString::SafeString( const QString &str, bool safe )
 
44
  : m_nestedString( str, this ),
 
45
    m_safety( safe ? IsSafe : IsNotSafe ),
 
46
    m_needsescape( false )
 
47
{
 
48
 
 
49
}
 
50
 
 
51
SafeString::SafeString( const QString &str, Safety safety )
 
52
  : m_nestedString( str, this ),
 
53
    m_safety( safety ),
 
54
    m_needsescape( false )
 
55
{
 
56
 
 
57
}
 
58
 
 
59
SafeString::~SafeString()
 
60
{
 
61
}
 
62
 
 
63
void SafeString::setNeedsEscape( bool needsEscape )
 
64
{
 
65
  m_needsescape = needsEscape;
 
66
}
 
67
 
 
68
bool SafeString::needsEscape() const
 
69
{
 
70
  return m_needsescape;
 
71
}
 
72
 
 
73
void SafeString::setSafety( Grantlee::SafeString::Safety safety )
 
74
{
 
75
  m_safety = safety;
 
76
}
 
77
 
 
78
bool SafeString::isSafe() const
 
79
{
 
80
  return m_safety == IsSafe;
 
81
}
 
82
 
 
83
SafeString::NestedString::NestedString( SafeString *safeString )
 
84
    : m_safeString( safeString )
 
85
{
 
86
 
 
87
}
 
88
 
 
89
SafeString::NestedString::NestedString( const QString &content, SafeString *safeString )
 
90
  : QString( content ),
 
91
    m_safeString( safeString )
 
92
{
 
93
 
 
94
}
 
95
 
 
96
SafeString& SafeString::operator=( const SafeString &str )
 
97
{
 
98
  m_nestedString = str.m_nestedString;
 
99
  m_nestedString.m_safeString = this;
 
100
  m_safety = str.m_safety;
 
101
  m_needsescape = str.m_needsescape;
 
102
  return *this;
 
103
}
 
104
 
 
105
SafeString SafeString::operator+( const QString &str )
 
106
{
 
107
  return SafeString( m_nestedString + str, IsNotSafe );
 
108
}
 
109
 
 
110
SafeString SafeString::operator+( const SafeString &str )
 
111
{
 
112
  if ( !str.isSafe() )
 
113
    return SafeString( m_nestedString + str.get(), IsNotSafe );
 
114
  return SafeString( m_nestedString + str.get(), m_safety );
 
115
}
 
116
 
 
117
SafeString &SafeString::operator+=( const QString &str )
 
118
{
 
119
  m_safety = IsNotSafe;
 
120
 
 
121
  m_nestedString += str;
 
122
  return *this;
 
123
}
 
124
 
 
125
SafeString &SafeString::operator+=( const SafeString &str )
 
126
{
 
127
  if ( !str.isSafe() )
 
128
    m_safety = IsNotSafe;
 
129
 
 
130
  m_nestedString += str.get();
 
131
  return *this;
 
132
}
 
133
 
 
134
bool SafeString::operator==( const Grantlee::SafeString &other ) const
 
135
{
 
136
  // Don't compare safety or account for future escaping here.
 
137
  // See TestBuiltins testEscaping
 
138
  return m_nestedString == other.get();
 
139
}
 
140
 
 
141
bool SafeString::operator==( const QString &other ) const
 
142
{
 
143
  return m_nestedString == other;
 
144
}
 
145
 
 
146
SafeString& SafeString::NestedString::append( const SafeString &str )
 
147
{
 
148
  QString::append( str.get() );
 
149
  if ( !str.isSafe() )
 
150
    m_safeString->m_safety = IsNotSafe;
 
151
 
 
152
  return *m_safeString;
 
153
}
 
154
 
 
155
SafeString& SafeString::NestedString::append( const QString &str )
 
156
{
 
157
  QString::append( str );
 
158
  m_safeString->m_safety = IsNotSafe;
 
159
  return *m_safeString;
 
160
}
 
161
 
 
162
SafeString& SafeString::NestedString::append( const QStringRef &reference )
 
163
{
 
164
  QString::append( reference );
 
165
  m_safeString->m_safety = IsNotSafe;
 
166
  return *m_safeString;
 
167
}
 
168
 
 
169
SafeString& SafeString::NestedString::append( const QLatin1String &str )
 
170
{
 
171
  QString::append( str );
 
172
  m_safeString->m_safety = IsNotSafe;
 
173
  return *m_safeString;
 
174
}
 
175
 
 
176
SafeString& SafeString::NestedString::append( const QByteArray &ba )
 
177
{
 
178
  QString::append( ba );
 
179
  m_safeString->m_safety = IsNotSafe;
 
180
  return *m_safeString;
 
181
}
 
182
 
 
183
SafeString& SafeString::NestedString::append( const char *str )
 
184
{
 
185
  QString::append( str );
 
186
  m_safeString->m_safety = IsNotSafe;
 
187
  return *m_safeString;
 
188
}
 
189
 
 
190
SafeString& SafeString::NestedString::append( const QChar ch )
 
191
{
 
192
  QString::append( ch );
 
193
  m_safeString->m_safety = IsNotSafe;
 
194
  return *m_safeString;
 
195
}
 
196
 
 
197
void SafeString::NestedString::chop( int n )
 
198
{
 
199
  QString::chop( n );
 
200
  m_safeString->m_safety = IsNotSafe;
 
201
}
 
202
 
 
203
SafeString& SafeString::NestedString::fill( QChar ch, int size )
 
204
{
 
205
  QString::fill( ch, size );
 
206
  m_safeString->m_safety = IsNotSafe;
 
207
  return *m_safeString;
 
208
}
 
209
 
 
210
SafeString& SafeString::NestedString::insert( int position, const Grantlee::SafeString &str )
 
211
{
 
212
  QString::insert( position, str.get() );
 
213
  if ( !str.isSafe() )
 
214
    m_safeString->m_safety = IsNotSafe;
 
215
 
 
216
  return *m_safeString;
 
217
}
 
218
 
 
219
SafeString& SafeString::NestedString::insert( int position, const QString &str )
 
220
{
 
221
  QString::insert( position, str );
 
222
  return *m_safeString;
 
223
}
 
224
 
 
225
SafeString& SafeString::NestedString::insert( int position, const QLatin1String &str )
 
226
{
 
227
  QString::insert( position, str );
 
228
  return *m_safeString;
 
229
}
 
230
 
 
231
SafeString& SafeString::NestedString::insert( int position, const QChar *unicode, int size )
 
232
{
 
233
  QString::insert( position, unicode, size );
 
234
  return *m_safeString;
 
235
}
 
236
 
 
237
SafeString& SafeString::NestedString::insert( int position, QChar ch )
 
238
{
 
239
  QString::insert( position, ch );
 
240
  return *m_safeString;
 
241
}
 
242
 
 
243
SafeString SafeString::NestedString::left( int n ) const
 
244
{
 
245
  return SafeString( QString::left( n ), m_safeString->m_safety );
 
246
}
 
247
 
 
248
SafeString SafeString::NestedString::leftJustified( int width, QChar fill, bool truncate ) const
 
249
{
 
250
  return SafeString( QString::leftJustified( width, fill, truncate ), m_safeString->m_safety );
 
251
}
 
252
 
 
253
SafeString SafeString::NestedString::mid( int position, int n ) const
 
254
{
 
255
  return SafeString( QString::mid( position, n ), m_safeString->m_safety );
 
256
}
 
257
 
 
258
SafeString SafeString::NestedString::normalized( QString::NormalizationForm mode ) const
 
259
{
 
260
  return SafeString( QString::normalized( mode ), m_safeString->m_safety );
 
261
}
 
262
 
 
263
SafeString SafeString::NestedString::normalized( QString::NormalizationForm mode, QChar::UnicodeVersion version ) const
 
264
{
 
265
  return SafeString( QString::normalized( mode, version ), m_safeString->m_safety );
 
266
}
 
267
 
 
268
SafeString& SafeString::NestedString::prepend( const Grantlee::SafeString &str )
 
269
{
 
270
  QString::prepend( str.get() );
 
271
  if ( !str.isSafe() )
 
272
    m_safeString->m_safety = IsNotSafe;
 
273
 
 
274
  return *m_safeString;
 
275
}
 
276
 
 
277
SafeString& SafeString::NestedString::prepend( const QString &str )
 
278
{
 
279
  QString::prepend( str );
 
280
  m_safeString->m_safety = IsNotSafe;
 
281
  return *m_safeString;
 
282
}
 
283
 
 
284
SafeString& SafeString::NestedString::prepend( const QLatin1String &str )
 
285
{
 
286
  QString::prepend( str );
 
287
  m_safeString->m_safety = IsNotSafe;
 
288
  return *m_safeString;
 
289
}
 
290
 
 
291
SafeString& SafeString::NestedString::prepend( const QByteArray &ba )
 
292
{
 
293
  QString::prepend( ba );
 
294
  m_safeString->m_safety = IsNotSafe;
 
295
  return *m_safeString;
 
296
}
 
297
 
 
298
SafeString& SafeString::NestedString::prepend( const char *str )
 
299
{
 
300
  QString::prepend( str );
 
301
  m_safeString->m_safety = IsNotSafe;
 
302
  return *m_safeString;
 
303
}
 
304
 
 
305
SafeString& SafeString::NestedString::prepend( QChar ch )
 
306
{
 
307
  QString::prepend( ch );
 
308
  m_safeString->m_safety = IsNotSafe;
 
309
  return *m_safeString;
 
310
}
 
311
 
 
312
void SafeString::NestedString::push_back( const Grantlee::SafeString &other )
 
313
{
 
314
  QString::push_back( other.get() );
 
315
  m_safeString->m_safety = other.m_safety;
 
316
}
 
317
 
 
318
void SafeString::NestedString::push_front( const Grantlee::SafeString &other )
 
319
{
 
320
  QString::push_front( other.get() );
 
321
  m_safeString->m_safety = other.m_safety;
 
322
}
 
323
 
 
324
SafeString& SafeString::NestedString::remove( int position, int n )
 
325
{
 
326
  QString::remove( position, n );
 
327
  m_safeString->m_safety = IsNotSafe;
 
328
  return *m_safeString;
 
329
}
 
330
 
 
331
SafeString& SafeString::NestedString::remove( QChar ch, Qt::CaseSensitivity cs )
 
332
{
 
333
  QString::remove( ch, cs );
 
334
  m_safeString->m_safety = IsNotSafe;
 
335
  return *m_safeString;
 
336
}
 
337
 
 
338
SafeString& SafeString::NestedString::remove( const Grantlee::SafeString &str, Qt::CaseSensitivity cs )
 
339
{
 
340
  QString::remove( str, cs );
 
341
  m_safeString->m_safety = IsNotSafe;
 
342
  return *m_safeString;
 
343
}
 
344
 
 
345
SafeString& SafeString::NestedString::remove( const QString &str, Qt::CaseSensitivity cs )
 
346
{
 
347
  QString::remove( str, cs );
 
348
  m_safeString->m_safety = IsNotSafe;
 
349
  return *m_safeString;
 
350
}
 
351
 
 
352
SafeString& SafeString::NestedString::remove( const QRegExp &rx )
 
353
{
 
354
  QString::remove( rx );
 
355
  m_safeString->m_safety = IsNotSafe;
 
356
  return *m_safeString;
 
357
}
 
358
 
 
359
SafeString SafeString::NestedString::repeated( int times ) const
 
360
{
 
361
  return SafeString( QString::repeated( times ), m_safeString->m_safety );
 
362
}
 
363
 
 
364
SafeString& SafeString::NestedString::replace( int position, int n, const Grantlee::SafeString &after )
 
365
{
 
366
  QString::replace( position, n, after.get() );
 
367
  m_safeString->m_safety = after.m_safety;
 
368
  return *m_safeString;
 
369
}
 
370
 
 
371
SafeString& SafeString::NestedString::replace( int position, int n, const QString &after )
 
372
{
 
373
  QString::replace( position, n, after );
 
374
  m_safeString->m_safety = IsNotSafe;
 
375
  return *m_safeString;
 
376
}
 
377
 
 
378
SafeString& SafeString::NestedString::replace( int position, int n, const QChar *unicode, int size )
 
379
{
 
380
  QString::replace( position, n, unicode, size );
 
381
  m_safeString->m_safety = IsNotSafe;
 
382
  return *m_safeString;
 
383
}
 
384
 
 
385
SafeString& SafeString::NestedString::replace( int position, int n, QChar after )
 
386
{
 
387
  QString::replace( position, n, after );
 
388
  m_safeString->m_safety = IsNotSafe;
 
389
  return *m_safeString;
 
390
}
 
391
 
 
392
SafeString& SafeString::NestedString::replace( const Grantlee::SafeString &before, const Grantlee::SafeString &after, Qt::CaseSensitivity cs )
 
393
{
 
394
  QString::replace( before.get(), after.get(), cs );
 
395
  m_safeString->m_safety = after.m_safety;
 
396
  return *m_safeString;
 
397
}
 
398
 
 
399
SafeString& SafeString::NestedString::replace( const QString &before, const Grantlee::SafeString &after, Qt::CaseSensitivity cs )
 
400
{
 
401
  QString::replace( before, after.get(), cs );
 
402
  m_safeString->m_safety = IsNotSafe;
 
403
  return *m_safeString;
 
404
}
 
405
 
 
406
SafeString& SafeString::NestedString::replace( const Grantlee::SafeString &before, const QString &after, Qt::CaseSensitivity cs )
 
407
{
 
408
  QString::replace( before.get(), after, cs );
 
409
  m_safeString->m_safety = IsNotSafe;
 
410
  return *m_safeString;
 
411
}
 
412
 
 
413
SafeString& SafeString::NestedString::replace( const QString &before, const QString &after, Qt::CaseSensitivity cs )
 
414
{
 
415
  QString::replace( before, after, cs );
 
416
  m_safeString->m_safety = IsNotSafe;
 
417
  return *m_safeString;
 
418
}
 
419
 
 
420
SafeString& SafeString::NestedString::replace( const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs )
 
421
{
 
422
  QString::replace( before, blen, after, alen, cs );
 
423
  m_safeString->m_safety = IsNotSafe;
 
424
  return *m_safeString;
 
425
}
 
426
 
 
427
SafeString& SafeString::NestedString::replace( QChar ch, const SafeString &after, Qt::CaseSensitivity cs )
 
428
{
 
429
  QString::replace( ch, after.get(), cs );
 
430
  m_safeString->m_safety = after.m_safety;
 
431
  return *m_safeString;
 
432
}
 
433
 
 
434
SafeString& SafeString::NestedString::replace( QChar ch, const QString &after, Qt::CaseSensitivity cs )
 
435
{
 
436
  QString::replace( ch, after, cs );
 
437
  m_safeString->m_safety = IsNotSafe;
 
438
  return *m_safeString;
 
439
}
 
440
 
 
441
SafeString& SafeString::NestedString::replace( QChar before, QChar after, Qt::CaseSensitivity cs )
 
442
{
 
443
  QString::replace( before, after, cs );
 
444
  m_safeString->m_safety = IsNotSafe;
 
445
  return *m_safeString;
 
446
}
 
447
 
 
448
SafeString& SafeString::NestedString::replace( const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs )
 
449
{
 
450
  QString::replace( before, after, cs );
 
451
  m_safeString->m_safety = IsNotSafe;
 
452
  return *m_safeString;
 
453
}
 
454
 
 
455
SafeString& SafeString::NestedString::replace( const QLatin1String &before, const Grantlee::SafeString &after, Qt::CaseSensitivity cs )
 
456
{
 
457
  QString::replace( before, after.get(), cs );
 
458
  m_safeString->m_safety = after.m_safety;
 
459
  return *m_safeString;
 
460
}
 
461
 
 
462
SafeString& SafeString::NestedString::replace( const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs )
 
463
{
 
464
  QString::replace( before, after, cs );
 
465
  m_safeString->m_safety = IsNotSafe;
 
466
  return *m_safeString;
 
467
}
 
468
 
 
469
SafeString& SafeString::NestedString::replace( const Grantlee::SafeString &before, const QLatin1String &after, Qt::CaseSensitivity cs )
 
470
{
 
471
  QString::replace( before.get(), after, cs );
 
472
  m_safeString->m_safety = before.m_safety;
 
473
  return *m_safeString;
 
474
}
 
475
 
 
476
SafeString& SafeString::NestedString::replace( const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs )
 
477
{
 
478
  QString::replace( before, after, cs );
 
479
  m_safeString->m_safety = IsNotSafe;
 
480
  return *m_safeString;
 
481
}
 
482
 
 
483
SafeString& SafeString::NestedString::replace( QChar c, const QLatin1String &after, Qt::CaseSensitivity cs )
 
484
{
 
485
  QString::replace( c, after, cs );
 
486
  m_safeString->m_safety = IsNotSafe;
 
487
  return *m_safeString;
 
488
}
 
489
 
 
490
SafeString& SafeString::NestedString::replace( const QRegExp &rx, const Grantlee::SafeString &after )
 
491
{
 
492
  QString::replace( rx, after.get() );
 
493
  m_safeString->m_safety = after.m_safety;
 
494
  return *m_safeString;
 
495
}
 
496
 
 
497
SafeString& SafeString::NestedString::replace( const QRegExp &rx, const QString &after )
 
498
{
 
499
  QString::replace( rx, after );
 
500
  m_safeString->m_safety = IsNotSafe;
 
501
  return *m_safeString;
 
502
}
 
503
 
 
504
SafeString SafeString::NestedString::right( int n ) const
 
505
{
 
506
  return SafeString( QString::right( n ), m_safeString->m_safety );
 
507
}
 
508
 
 
509
SafeString SafeString::NestedString::rightJustified( int width, QChar fill, bool truncate ) const
 
510
{
 
511
  return SafeString( QString::rightJustified( width, fill, truncate ), m_safeString->m_safety );
 
512
}
 
513
 
 
514
SafeString SafeString::NestedString::section( const QRegExp &reg, int start, int end, QString::SectionFlags flags ) const
 
515
{
 
516
  return SafeString( QString::section( reg, start, end, flags ), m_safeString->m_safety );
 
517
}
 
518
 
 
519
SafeString SafeString::NestedString::section( QChar sep, int start, int end, QString::SectionFlags flags ) const
 
520
{
 
521
  return SafeString( QString::section( sep, start, end, flags ), m_safeString->m_safety );
 
522
}
 
523
 
 
524
SafeString SafeString::NestedString::section( const Grantlee::SafeString &sep, int start, int end, QString::SectionFlags flags ) const
 
525
{
 
526
  return SafeString( QString::section( sep, start, end, flags ), m_safeString->m_safety );
 
527
}
 
528
 
 
529
SafeString SafeString::NestedString::section( const QString &sep, int start, int end, QString::SectionFlags flags ) const
 
530
{
 
531
  return SafeString( QString::section( sep, start, end, flags ), m_safeString->m_safety );
 
532
}
 
533
 
 
534
SafeString& SafeString::NestedString::setNum( int n, int base )
 
535
{
 
536
  QString::setNum( n, base );
 
537
  m_safeString->m_safety = IsNotSafe;
 
538
  return *m_safeString;
 
539
}
 
540
 
 
541
SafeString& SafeString::NestedString::setNum( uint n, int base )
 
542
{
 
543
  QString::setNum( n, base );
 
544
  m_safeString->m_safety = IsNotSafe;
 
545
  return *m_safeString;
 
546
}
 
547
 
 
548
SafeString& SafeString::NestedString::setNum( long int n, int base )
 
549
{
 
550
  QString::setNum( n, base );
 
551
  m_safeString->m_safety = IsNotSafe;
 
552
  return *m_safeString;
 
553
}
 
554
 
 
555
SafeString& SafeString::NestedString::setNum( ulong n, int base )
 
556
{
 
557
  QString::setNum( n, base );
 
558
  m_safeString->m_safety = IsNotSafe;
 
559
  return *m_safeString;
 
560
}
 
561
 
 
562
SafeString& SafeString::NestedString::setNum( qlonglong n, int base )
 
563
{
 
564
  QString::setNum( n, base );
 
565
  m_safeString->m_safety = IsNotSafe;
 
566
  return *m_safeString;
 
567
}
 
568
 
 
569
SafeString& SafeString::NestedString::setNum( qulonglong n, int base )
 
570
{
 
571
  QString::setNum( n, base );
 
572
  m_safeString->m_safety = IsNotSafe;
 
573
  return *m_safeString;
 
574
}
 
575
 
 
576
SafeString& SafeString::NestedString::setNum( short int n, int base )
 
577
{
 
578
  QString::setNum( n, base );
 
579
  m_safeString->m_safety = IsNotSafe;
 
580
  return *m_safeString;
 
581
}
 
582
 
 
583
SafeString& SafeString::NestedString::setNum( ushort n, int base )
 
584
{
 
585
  QString::setNum( n, base );
 
586
  m_safeString->m_safety = IsNotSafe;
 
587
  return *m_safeString;
 
588
}
 
589
 
 
590
SafeString& SafeString::NestedString::setNum( double n, char format, int precision )
 
591
{
 
592
  QString::setNum( n, format, precision );
 
593
  m_safeString->m_safety = IsNotSafe;
 
594
  return *m_safeString;
 
595
}
 
596
 
 
597
SafeString& SafeString::NestedString::setNum( float n, char format, int precision )
 
598
{
 
599
  QString::setNum( n, format, precision );
 
600
  m_safeString->m_safety = IsNotSafe;
 
601
  return *m_safeString;
 
602
}
 
603
 
 
604
SafeString& SafeString::NestedString::setUnicode( const QChar *unicode, int size )
 
605
{
 
606
  QString::setUnicode( unicode, size );
 
607
  m_safeString->m_safety = IsNotSafe;
 
608
  return *m_safeString;
 
609
}
 
610
 
 
611
SafeString& SafeString::NestedString::setUtf16( const ushort *unicode, int size )
 
612
{
 
613
  QString::setUtf16( unicode, size );
 
614
  m_safeString->m_safety = IsNotSafe;
 
615
  return *m_safeString;
 
616
}
 
617
 
 
618
SafeString SafeString::NestedString::simplified() const
 
619
{
 
620
  return SafeString( QString::simplified(), m_safeString->m_safety );
 
621
}
 
622
 
 
623
QStringList SafeString::NestedString::split( const Grantlee::SafeString &sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs ) const
 
624
{
 
625
  return QString::split( sep.get(), behavior, cs );
 
626
}
 
627
 
 
628
QStringList SafeString::NestedString::split( const QString &sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs ) const
 
629
{
 
630
  return QString::split( sep, behavior, cs );
 
631
}
 
632
 
 
633
QStringList SafeString::NestedString::split( const QChar &sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs ) const
 
634
{
 
635
  return QString::split( sep, behavior, cs );
 
636
}
 
637
 
 
638
QStringList SafeString::NestedString::split( const QRegExp &rx, QString::SplitBehavior behavior ) const
 
639
{
 
640
  return QString::split( rx, behavior );
 
641
}
 
642
 
 
643
SafeString SafeString::NestedString::toLower() const
 
644
{
 
645
  return SafeString( QString::toLower(), IsNotSafe );
 
646
}
 
647
 
 
648
SafeString SafeString::NestedString::toUpper() const
 
649
{
 
650
  return SafeString( QString::toUpper(), IsNotSafe );
 
651
}
 
652
 
 
653
SafeString SafeString::NestedString::trimmed() const
 
654
{
 
655
  return SafeString( QString::trimmed(), m_safeString->m_safety );
 
656
}