To get this branch, use:
bzr branch
http://bzr.ed.am/elec/propeller-clock
« back to all changes in this revision
Viewing changes to src/utility/string
- browse files at revision 48
- compare with another revision
- download diff
- download tarball
- view history from revision 48
- Committer: edam
- Date: 2012-02-16 00:08:37 UTC
- Revision ID: edam@waxworlds.org-20120216000837-ozbyl61w2n2thwa0
update arduino.mk
- files added:
- src/util/Bounce.cpp
- files removed:
- src/analogue_clock_mode.cc
- src/utility
- files modified:
- arduino.mk
added
removed
src/utility/string
1
/* Copyright (C) 2004 Garrett A. Kajmowicz
2
3
This file is part of the uClibc++ Library.
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
This library is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
You should have received a copy of the GNU Lesser General Public
16
License along with this library; if not, write to the Free Software
17
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
*/
19
20
#include <basic_definitions>
21
#include <char_traits>
22
#include <string.h>
23
#include <func_exception>
24
#include <memory>
25
#include <vector>
26
27
28
#ifdef __UCLIBCXX_HAS_WCHAR__
29
#include <cwchar>
30
#include <cwctype>
31
#endif
32
33
#ifndef __HEADER_STD_STRING
34
#define __HEADER_STD_STRING 1
35
36
#pragma GCC visibility push(default)
37
38
namespace std{
39
40
//Basic basic_string
41
42
template<class Ch, class Tr = char_traits<Ch>, class A = allocator<Ch> > class basic_string;
43
44
typedef basic_string<char> string;
45
#ifdef __UCLIBCXX_HAS_WCHAR__
46
typedef basic_string<wchar_t> wstring;
47
#endif
48
49
50
51
//template<class Ch, class Tr = char_traits<Ch>, class A = allocator<Ch> > class _UCXXEXPORT basic_string
52
template<class Ch, class Tr, class A> class basic_string
53
: public std::vector<Ch, A>
54
{
55
public:
56
typedef Tr traits_type;
57
typedef typename Tr::char_type value_type;
58
typedef A allocator_type;
59
typedef typename A::size_type size_type;
60
typedef typename A::difference_type difference_type;
61
62
typedef typename A::reference reference;
63
typedef typename A::const_reference const_reference;
64
typedef typename A::pointer pointer;
65
typedef typename A::const_pointer const_pointer;
66
67
typedef typename vector<Ch, A>::iterator iterator;
68
typedef typename vector<Ch, A>::const_iterator const_iterator;
69
70
typedef typename vector<Ch, A>::reverse_iterator reverse_iterator;
71
typedef typename vector<Ch, A>::const_reverse_iterator const_reverse_iterator;
72
73
static const size_type npos = (size_type)-1;
74
75
explicit _UCXXEXPORT basic_string(const A& al = A()) : vector<Ch, A>(al){ return; }
76
77
_UCXXEXPORT basic_string(const basic_string& str, size_type pos = 0, size_type n = npos, const A& al = A()); //Below
78
79
_UCXXEXPORT basic_string(const Ch* s, size_type n, const A& al = A())
80
: vector<Ch, A>(al)
81
{
82
if(n == npos){
83
__throw_out_of_range();
84
}
85
if(s > 0){
86
resize(n);
87
Tr::copy(vector<Ch, A>::data, s, vector<Ch, A>::elements);
88
}
89
}
90
91
_UCXXEXPORT basic_string(const Ch* s, const A& al = A()); //Below
92
93
_UCXXEXPORT basic_string(size_type n, Ch c, const A& al = A())
94
: vector<Ch, A>(n, c, al)
95
{
96
}
97
98
template<class InputIterator> _UCXXEXPORT basic_string(InputIterator begin, InputIterator end, const A& a = A())
99
:vector<Ch, A>(begin, end)
100
{
101
102
}
103
104
_UCXXEXPORT ~basic_string() {
105
return;
106
}
107
108
_UCXXEXPORT basic_string& operator=(const basic_string& str); //Below
109
110
_UCXXEXPORT basic_string& operator=(const Ch* s){
111
vector<Ch, A>::clear();
112
if(s!=0){
113
size_type len = Tr::length(s);
114
resize(len);
115
Tr::copy( vector<Ch, A>::data, s, len);
116
}
117
return *this;
118
}
119
120
_UCXXEXPORT basic_string& operator=(Ch c){
121
vector<Ch, A>::clear();
122
vector<Ch, A>::push_back(c);
123
return *this;
124
}
125
126
inline _UCXXEXPORT size_type length() const { return vector<Ch, A>::size(); }
127
128
void _UCXXEXPORT resize(size_type n, Ch c = Ch()){
129
vector<Ch, A>::resize(n, c);
130
}
131
132
_UCXXEXPORT basic_string& operator+=(const basic_string& str){
133
return append(str);
134
}
135
136
_UCXXEXPORT basic_string& operator+=(const Ch * s){
137
return append(s);
138
}
139
140
_UCXXEXPORT basic_string& operator+=(Ch c){
141
vector<Ch, A>::push_back(c);
142
return *this;
143
}
144
145
_UCXXEXPORT basic_string& append(const basic_string& str){
146
size_t temp = vector<Ch, A>::elements;
147
resize(vector<Ch, A>::elements + str.elements);
148
Tr::copy( vector<Ch, A>::data + temp, str.vector<Ch, A>::data, str.elements);
149
150
return *this;
151
}
152
153
_UCXXEXPORT basic_string& append(const basic_string& str, size_type pos, size_type n){
154
if(pos > str.size()){
155
__throw_out_of_range();
156
}
157
158
size_type rlen = str.elements - pos;
159
if(rlen > n){
160
rlen = n;
161
}
162
if(vector<Ch, A>::elements > npos - rlen){
163
__throw_length_error();
164
}
165
size_t temp = vector<Ch, A>::elements;
166
resize(vector<Ch, A>::elements + rlen);
167
Tr::copy( vector<Ch, A>::data + temp, str.vector<Ch, A>::data + pos, rlen);
168
return *this;
169
}
170
171
_UCXXEXPORT basic_string& append(const Ch* s, size_type n){
172
size_t temp = vector<Ch, A>::elements;
173
resize(vector<Ch, A>::elements + n);
174
Tr::copy( vector<Ch, A>::data + temp, s, n);
175
return *this;
176
}
177
178
_UCXXEXPORT basic_string& append(const Ch* s){
179
size_type strLen = Tr::length(s);
180
size_t temp = vector<Ch, A>::elements;
181
resize(vector<Ch, A>::elements + strLen);
182
Tr::copy( vector<Ch, A>::data + temp, s, strLen);
183
return *this;
184
}
185
186
_UCXXEXPORT basic_string& append(size_type n, Ch c){
187
vector<Ch, A>::resize(vector<Ch, A>::elements + n, c);
188
return *this;
189
}
190
191
_UCXXEXPORT basic_string& assign(const basic_string& str){
192
operator=(str);
193
return *this;
194
}
195
196
_UCXXEXPORT basic_string& assign(const basic_string& str, size_type pos, size_type n){
197
if(pos > str.elements){
198
__throw_out_of_range();
199
}
200
size_type r = str.elements - pos;
201
if(r > n){
202
r = n;
203
}
204
resize(r);
205
Tr::copy(vector<Ch, A>::data, str.vector<Ch, A>::data + pos, r);
206
return *this;
207
}
208
209
_UCXXEXPORT basic_string& assign(const Ch* s, size_type n){
210
resize(n);
211
Tr::copy(vector<Ch, A>::data, s, n);
212
return *this;
213
}
214
215
_UCXXEXPORT basic_string& assign(const Ch* s){
216
size_type len = Tr::length(s);
217
return assign(s, len);
218
}
219
220
_UCXXEXPORT basic_string& assign(size_type n, Ch c){
221
vector<Ch, A>::clear();
222
vector<Ch, A>::resize(n, Ch() );
223
return *this;
224
}
225
226
template<class InputIterator> _UCXXEXPORT basic_string& assign(InputIterator first, InputIterator last){
227
vector<Ch, A>::resize(0, Ch());
228
while (first != last){
229
append(*first);
230
++first;
231
}
232
return *this;
233
}
234
235
_UCXXEXPORT basic_string& insert(size_type pos1, const basic_string& str, size_type pos2=0, size_type n=npos){
236
if(pos1 > vector<Ch, A>::elements || pos2 > str.elements){
237
__throw_out_of_range();
238
}
239
size_type r = str.elements - pos2;
240
if( r > n){
241
r = n;
242
}
243
if(vector<Ch, A>::elements > npos - r){
244
__throw_length_error();
245
}
246
size_type temp = vector<Ch, A>::elements;
247
resize(vector<Ch, A>::elements + r);
248
Tr::move(vector<Ch, A>::data + pos1 + r, vector<Ch, A>::data + pos1, temp - pos1);
249
Tr::copy(vector<Ch, A>::data + pos1, str.vector<Ch, A>::data + pos2, r);
250
return *this;
251
}
252
253
_UCXXEXPORT basic_string& insert(size_type pos, const Ch* s, size_type n){
254
if(pos > vector<Ch, A>::elements){
255
__throw_out_of_range();
256
}
257
if(vector<Ch, A>::elements > npos - n){
258
__throw_length_error();
259
}
260
size_type temp = vector<Ch, A>::elements;
261
resize(vector<Ch, A>::elements + n);
262
Tr::move(vector<Ch, A>::data + pos + n, vector<Ch, A>::data + pos, temp - pos);
263
Tr::copy(vector<Ch, A>::data + pos, s, n);
264
return *this;
265
}
266
267
inline _UCXXEXPORT basic_string& insert(size_type pos, const Ch* s){
268
size_type len = Tr::length(s);
269
return insert(pos, s, len);
270
}
271
272
_UCXXEXPORT basic_string& insert(size_type pos, size_type n, Ch c){
273
if(pos > vector<Ch, A>::elements){
274
__throw_out_of_range();
275
}
276
if(vector<Ch, A>::elements > npos - n){
277
__throw_length_error();
278
}
279
size_type temp = vector<Ch, A>::elements;
280
resize(vector<Ch, A>::elements + n);
281
Tr::move(vector<Ch, A>::data + pos + n, vector<Ch, A>::data + pos, temp - pos);
282
Tr::assign(vector<Ch, A>::data + pos, n, c);
283
return *this;
284
}
285
286
using vector<Ch, A>::insert;
287
// void insert(iterator p, size_type n, charT c);
288
// template<class InputIterator> void insert(iterator p, InputIterator first, InputIterator last);
289
290
_UCXXEXPORT basic_string& erase(size_type pos = 0, size_type n = npos){
291
size_type xlen = vector<Ch, A>::elements - pos;
292
293
if(xlen > n){
294
xlen = n;
295
}
296
size_type temp = vector<Ch, A>::elements;
297
298
Tr::move(vector<Ch, A>::data + pos, vector<Ch, A>::data + pos + xlen, temp - pos - xlen);
299
resize(temp - xlen);
300
return *this;
301
}
302
303
_UCXXEXPORT iterator erase(iterator position){
304
if(position == vector<Ch, A>::end()){
305
return position;
306
}
307
308
++position;
309
310
iterator temp = position;
311
312
while(position != vector<Ch, A>::end()){
313
*(position-1) = *position;
314
++position;
315
}
316
vector<Ch, A>::pop_back();
317
return temp;
318
}
319
320
_UCXXEXPORT iterator erase(iterator first, iterator last){
321
size_t count = last - first;
322
323
iterator temp = last;
324
325
while(last != vector<Ch, A>::end()){
326
*(last - count) = *last;
327
++last;
328
}
329
330
resize( vector<Ch, A>::elements-count);
331
332
return temp;
333
}
334
335
_UCXXEXPORT basic_string&
336
replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2=0, size_type n2=npos)
337
{
338
if(pos1 > vector<Ch, A>::elements){
339
__throw_out_of_range();
340
}
341
size_type xlen = vector<Ch, A>::elements - pos1;
342
if(xlen > n1){
343
xlen = n1;
344
}
345
size_type rlen = str.elements - pos2;
346
if(rlen > n2){
347
rlen = n2;
348
}
349
if((vector<Ch, A>::elements - xlen) >= (npos - rlen)){
350
__throw_length_error();
351
}
352
353
size_t temp = vector<Ch, A>::elements;
354
355
if(rlen > xlen){ //Only if making larger
356
resize(temp - xlen + rlen);
357
}
358
359
//Final length = vector<Ch, A>::elements - xlen + rlen
360
//Initial block is of size pos1
361
//Block 2 is of size len
362
363
Tr::move(vector<Ch, A>::data + pos1 + rlen, vector<Ch, A>::data + pos1 + xlen, temp - pos1 - xlen);
364
Tr::copy(vector<Ch, A>::data + pos1, str.vector<Ch, A>::data + pos2, rlen);
365
resize(temp - xlen + rlen);
366
return *this;
367
}
368
369
_UCXXEXPORT basic_string& replace(size_type pos, size_type n1, const Ch* s, size_type n2){
370
return replace(pos,n1,basic_string<Ch,Tr,A>(s,n2));
371
372
}
373
374
inline _UCXXEXPORT basic_string& replace(size_type pos, size_type n1, const Ch* s){
375
return replace(pos,n1,basic_string<Ch,Tr,A>(s));
376
}
377
378
_UCXXEXPORT basic_string& replace(size_type pos, size_type n1, size_type n2, Ch c){
379
return replace(pos,n1,basic_string<Ch, Tr, A>(n2,c));
380
}
381
// _UCXXEXPORT basic_string& replace(iterator i1, iterator i2, const basic_string& str);
382
// _UCXXEXPORT basic_string& replace(iterator i1, iterator i2, const Ch* s, size_type n);
383
// _UCXXEXPORT basic_string& replace(iterator i1, iterator i2, const Ch* s);
384
// _UCXXEXPORT basic_string& replace(iterator i1, iterator i2, size_type n, Ch c);
385
/* template<class InputIterator> _UCXXEXPORT basic_string& replace(iterator i1, iterator i2,
386
InputIterator j1, InputIterator j2);*/
387
388
size_type _UCXXEXPORT copy(Ch* s, size_type n, size_type pos = 0) const{
389
if(pos > vector<Ch, A>::elements){
390
__throw_out_of_range();
391
}
392
size_type r = vector<Ch, A>::elements - pos;
393
if(r > n){
394
r = n;
395
}
396
Tr::copy(s, vector<Ch, A>::data + pos, r);
397
return r;
398
}
399
400
_UCXXEXPORT void swap(basic_string<Ch,Tr,A>& s){
401
//Data pointers
402
403
vector<Ch, A>::swap(s);
404
}
405
406
_UCXXEXPORT const Ch* c_str() const{
407
const_cast<basic_string<Ch,Tr,A> *>(this)->reserve(vector<Ch, A>::elements+1);
408
vector<Ch, A>::data[vector<Ch, A>::elements] = 0; //Add 0 at the end
409
return vector<Ch, A>::data;
410
}
411
412
_UCXXEXPORT const Ch* data() const{
413
return vector<Ch, A>::data;
414
}
415
_UCXXEXPORT allocator_type get_allocator() const{
416
return vector<Ch, A>::a;
417
}
418
419
_UCXXEXPORT size_type find (const basic_string& str, size_type pos = 0) const; //Below
420
421
_UCXXEXPORT size_type find (const Ch* s, size_type pos, size_type n) const{
422
return find(basic_string<Ch, Tr, A>(s,n), pos);
423
}
424
_UCXXEXPORT size_type find (const Ch* s, size_type pos = 0) const{
425
return find(basic_string<Ch, Tr, A>(s), pos);
426
}
427
_UCXXEXPORT size_type find (Ch c, size_type pos = 0) const{
428
for(size_type i = pos; i < length(); ++i){
429
if(operator[](i) == c){
430
return i;
431
}
432
}
433
return npos;
434
}
435
_UCXXEXPORT size_type rfind(const basic_string& str, size_type pos = npos) const{
436
if(pos >= length()){
437
pos = length();
438
}
439
for(size_type i = pos; i > 0; --i){
440
if(str == substr(i-1, str.length())){
441
return i-1;
442
}
443
}
444
return npos;
445
}
446
_UCXXEXPORT size_type rfind(const Ch* s, size_type pos, size_type n) const{
447
return rfind(basic_string<Ch, Tr, A>(s,n),pos);
448
}
449
_UCXXEXPORT size_type rfind(const Ch* s, size_type pos = npos) const{
450
return rfind(basic_string<Ch, Tr, A>(s),pos);
451
}
452
_UCXXEXPORT size_type rfind(Ch c, size_type pos = npos) const{
453
return rfind(basic_string<Ch, Tr, A>(1,c),pos);
454
}
455
456
_UCXXEXPORT size_type find_first_of(const basic_string& str, size_type pos = 0) const{
457
for(size_type i = pos; i < length(); ++i){
458
for(size_type j = 0; j < str.length() ; ++j){
459
if( Tr::eq(str[j], operator[](i)) ){
460
return i;
461
}
462
}
463
}
464
return npos;
465
}
466
467
_UCXXEXPORT size_type find_first_of(const Ch* s, size_type pos, size_type n) const{
468
return find_first_of(basic_string<Ch, Tr, A>(s,n),pos);
469
}
470
_UCXXEXPORT size_type find_first_of(const Ch* s, size_type pos = 0) const{
471
return find_first_of(basic_string<Ch, Tr, A>(s),pos);
472
}
473
_UCXXEXPORT size_type find_first_of(Ch c, size_type pos = 0) const{
474
for(size_type i = pos; i< length(); ++i){
475
if( Tr::eq(operator[](i), c) ){
476
return i;
477
}
478
}
479
return npos;
480
}
481
482
_UCXXEXPORT size_type find_last_of (const basic_string& str, size_type pos = npos) const{
483
if(pos > length()){
484
pos = length();
485
}
486
for(size_type i = pos; i >0 ; --i){
487
for(size_type j = 0 ; j < str.length(); ++j){
488
if( Tr::eq(operator[](i-1), str[j]) ){
489
return i-1;
490
}
491
}
492
}
493
return npos;
494
}
495
_UCXXEXPORT size_type find_last_of (const Ch* s, size_type pos, size_type n) const{
496
return find_last_of(basic_string<Ch, Tr, A>(s,n),pos);
497
}
498
_UCXXEXPORT size_type find_last_of (const Ch* s, size_type pos = npos) const{
499
return find_last_of(basic_string<Ch, Tr, A>(s),pos);
500
}
501
_UCXXEXPORT size_type find_last_of (Ch c, size_type pos = npos) const{
502
if(pos > length()){
503
pos = length();
504
}
505
for(size_type i = pos; i >0 ; --i){
506
if( Tr::eq(operator[](i-1), c) ){
507
return i-1;
508
}
509
}
510
return npos;
511
}
512
513
_UCXXEXPORT size_type find_first_not_of(const basic_string& str, size_type pos = 0) const{
514
bool foundCharacter;
515
for(size_type i = pos; i < length(); ++i){
516
foundCharacter = false;
517
for(size_type j = 0; j < str.length() ; ++j){
518
if( Tr::eq(str[j], operator[](i)) ){
519
foundCharacter = true;
520
}
521
}
522
if(foundCharacter == false){
523
return i;
524
}
525
}
526
return npos;
527
}
528
529
_UCXXEXPORT size_type find_first_not_of(const Ch* s, size_type pos, size_type n) const{
530
return find_first_not_of(basic_string<Ch, Tr, A>(s,n),pos);
531
}
532
_UCXXEXPORT size_type find_first_not_of(const Ch* s, size_type pos = 0) const{
533
return find_first_not_of(basic_string<Ch, Tr, A>(s),pos);
534
}
535
_UCXXEXPORT size_type find_first_not_of(Ch c, size_type pos = 0) const{
536
for(size_type i = pos; i < length() ; ++i){
537
if(operator[](i) != c){
538
return i;
539
}
540
}
541
return npos;
542
}
543
_UCXXEXPORT size_type find_last_not_of (const basic_string& str, size_type pos = npos) const{
544
size_type xpos(length() - 1);
545
if(xpos > pos){
546
xpos = pos;
547
}
548
549
while(xpos != npos && npos != str.find_first_of(at(xpos))){
550
--xpos;
551
}
552
553
return xpos;
554
}
555
556
_UCXXEXPORT size_type find_last_not_of (const Ch* s, size_type pos, size_type n) const{
557
return find_last_not_of(basic_string<Ch, Tr, A>(s,n),pos);
558
}
559
_UCXXEXPORT size_type find_last_not_of (const Ch* s, size_type pos = npos) const{
560
return find_last_not_of(basic_string<Ch, Tr, A>(s),pos);
561
}
562
_UCXXEXPORT size_type find_last_not_of (Ch c, size_type pos = npos) const{
563
size_type xpos(length() - 1);
564
if(xpos > pos){
565
xpos = pos;
566
}
567
while(xpos != npos && Tr::eq(at(xpos), c)){
568
--xpos;
569
}
570
return xpos;
571
572
}
573
574
_UCXXEXPORT basic_string substr(size_type pos = 0, size_type n = npos) const;
575
576
_UCXXEXPORT int compare(const basic_string& str) const{
577
size_type rlen = vector<Ch, A>::elements;
578
if(rlen > str.elements){
579
rlen = str.elements;
580
}
581
int retval = Tr::compare(vector<Ch, A>::data, str.vector<Ch, A>::data, rlen);
582
if(retval == 0){
583
if(vector<Ch, A>::elements < str.elements){
584
retval = -1;
585
}
586
if(vector<Ch, A>::elements > str.elements){
587
retval = 1;
588
}
589
}
590
return retval;
591
}
592
593
_UCXXEXPORT int compare(size_type pos1, size_type n1, const basic_string& str,
594
size_type pos2=0, size_type n2=npos) const{
595
size_type len1 = vector<Ch, A>::elements - pos1;
596
if(len1 > n1){
597
len1 = n1;
598
}
599
size_type len2 = str.vector<Ch, A>::elements - pos2;
600
if(len2 > n2){
601
len2 = n2;
602
}
603
size_type rlen = len1;
604
if(rlen > len2){
605
rlen = len2;
606
}
607
int retval = Tr::compare(vector<Ch, A>::data + pos1, str.vector<Ch, A>::data + pos2, rlen);
608
if(retval == 0){
609
if(len1 < len2){
610
retval = -1;
611
}
612
if(len1 > len2){
613
retval = 1;
614
}
615
}
616
return retval;
617
}
618
619
_UCXXEXPORT int compare(const Ch* s) const{
620
size_type slen = Tr::length(s);
621
size_type rlen = slen;
622
if(rlen > vector<Ch, A>::elements){
623
rlen=vector<Ch, A>::elements;
624
}
625
int retval = Tr::compare(vector<Ch, A>::data, s, rlen);
626
if(retval==0){
627
if(vector<Ch, A>::elements < slen){
628
retval = -1;
629
}
630
if(vector<Ch, A>::elements > slen){
631
retval = 1;
632
}
633
}
634
return retval;
635
}
636
637
_UCXXEXPORT int compare(size_type pos1, size_type n1, const Ch* s, size_type n2 = npos) const{
638
size_type len1 = vector<Ch, A>::elements - pos1;
639
if(len1 > n1){
640
len1 = n1;
641
}
642
size_type slen = Tr::length(s);
643
size_type len2 = slen;
644
if(len2 > n2){
645
len2 = n2;
646
}
647
size_type rlen = len1;
648
if(rlen > len2){
649
rlen = len2;
650
}
651
int retval = Tr::compare(vector<Ch, A>::data + pos1, s, rlen);
652
if(retval == 0){
653
if(len1 < len2){
654
retval = -1;
655
}
656
if(len1 > len2){
657
retval = 1;
658
}
659
}
660
return retval;
661
}
662
663
};
664
665
666
//Functions
667
668
template<class Ch,class Tr,class A> _UCXXEXPORT basic_string<Ch,Tr,A>::basic_string(const Ch* s, const A& al)
669
: vector<Ch, A>(al)
670
{
671
if(s!=0){
672
size_type temp = Tr::length(s);
673
append(s, temp);
674
}
675
}
676
677
template<class Ch,class Tr,class A> _UCXXEXPORT basic_string<Ch,Tr,A>::
678
basic_string(const basic_string& str, size_type pos, size_type n, const A& al)
679
: vector<Ch, A>(al)
680
{
681
if(pos>str.size()){
682
__throw_out_of_range();
683
}
684
size_type rlen = str.size() - pos;
685
if( rlen > n){
686
rlen = n;
687
}
688
resize(rlen);
689
Tr::copy(vector<Ch, A>::data, str.vector<Ch, A>::data + pos, vector<Ch, A>::elements);
690
}
691
692
template<class Ch,class Tr,class A> _UCXXEXPORT basic_string<Ch,Tr,A>&
693
basic_string<Ch,Tr,A>::operator=(const basic_string<Ch,Tr,A> & str)
694
{
695
if(&str == this){ //Check if we are doing a=a
696
return *this;
697
}
698
vector<Ch, A>::clear();
699
resize(str.elements);
700
Tr::copy( vector<Ch, A>::data, str.vector<Ch, A>::data, str.elements);
701
return *this;
702
}
703
704
705
template<class Ch,class Tr,class A> _UCXXEXPORT typename basic_string<Ch,Tr,A>::size_type
706
basic_string<Ch,Tr,A>::find (const basic_string<Ch,Tr,A>& str, size_type pos) const
707
{
708
if(str.length() > length()){
709
return npos;
710
}
711
size_type max_string_start = 1 + length() - str.length();
712
for(size_type i = pos; i < max_string_start; ++i){
713
if(str == substr(i, str.length())){
714
return i;
715
}
716
}
717
return npos;
718
}
719
720
721
template<class Ch,class Tr,class A>
722
_UCXXEXPORT basic_string<Ch, Tr, A> basic_string<Ch,Tr,A>::substr(size_type pos, size_type n) const
723
{
724
if(pos > vector<Ch, A>::elements){
725
__throw_out_of_range();
726
}
727
size_type rlen = vector<Ch, A>::elements - pos;
728
if(rlen > n){
729
rlen = n;
730
}
731
return basic_string<Ch,Tr,A>(vector<Ch, A>::data + pos,rlen);
732
}
733
734
735
736
737
#ifdef __UCLIBCXX_EXPAND_STRING_CHAR__
738
#ifndef __UCLIBCXX_COMPILE_STRING__
739
740
#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__
741
742
template <> _UCXXEXPORT string::basic_string(const allocator<char> &);
743
template <> _UCXXEXPORT string::basic_string(size_type n, char c, const allocator<char> & );
744
template <> _UCXXEXPORT string::basic_string(const char* s, const allocator<char>& al);
745
template <> _UCXXEXPORT string::basic_string(const basic_string& str, size_type pos, size_type n, const allocator<char>& al);
746
template <> _UCXXEXPORT string::~basic_string();
747
748
#endif
749
750
template <> _UCXXEXPORT string & string::append(const char * s, size_type n);
751
752
753
template <> _UCXXEXPORT string::size_type string::find(const string & str, size_type pos) const;
754
template <> _UCXXEXPORT string::size_type string::find(const char* s, size_type pos) const;
755
template <> _UCXXEXPORT string::size_type string::find (char c, size_type pos) const;
756
757
template <> _UCXXEXPORT string::size_type string::rfind(const string & str, size_type pos) const;
758
template <> _UCXXEXPORT string::size_type string::rfind(char c, size_type pos) const;
759
template <> _UCXXEXPORT string::size_type string::rfind(const char* s, size_type pos) const;
760
761
template <> _UCXXEXPORT string::size_type string::find_first_of(const string &, size_type) const;
762
template <> _UCXXEXPORT string::size_type string::find_first_of(const char *, size_type pos, size_type n) const;
763
template <> _UCXXEXPORT string::size_type string::find_first_of(const char*, size_type pos) const;
764
template <> _UCXXEXPORT string::size_type string::find_first_of(char c, size_type pos) const;
765
766
template <> _UCXXEXPORT string::size_type string::find_last_of (const string & , size_type pos) const;
767
template <> _UCXXEXPORT string::size_type string::find_last_of (const char* s, size_type pos, size_type n) const;
768
template <> _UCXXEXPORT string::size_type string::find_last_of (const char* s, size_type pos) const;
769
template <> _UCXXEXPORT string::size_type string::find_last_of (char c, size_type pos) const;
770
771
template <> _UCXXEXPORT string::size_type string::find_first_not_of(const string &, size_type) const;
772
template <> _UCXXEXPORT string::size_type string::find_first_not_of(const char*, size_type, size_type) const;
773
template <> _UCXXEXPORT string::size_type string::find_first_not_of(const char*, size_type) const;
774
template <> _UCXXEXPORT string::size_type string::find_first_not_of(char c, size_type) const;
775
776
template <> _UCXXEXPORT int string::compare(const string & str) const;
777
template <> _UCXXEXPORT int string::compare(
778
size_type pos1, size_type n1, const string & str, size_type pos2, size_type n2) const;
779
780
template <> _UCXXEXPORT string string::substr(size_type pos, size_type n) const;
781
782
template <> _UCXXEXPORT string & string::operator=(const string & str);
783
template <> _UCXXEXPORT string & string::operator=(const char * s);
784
785
#endif
786
#endif
787
788
789
790
791
//typedef basic_string<char> string;
792
793
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_string<charT,traits,Allocator>
794
operator+(const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs)
795
{
796
basic_string<charT,traits,Allocator> temp(lhs);
797
temp.append(rhs);
798
return temp;
799
}
800
801
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_string<charT,traits,Allocator>
802
operator+(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs)
803
{
804
basic_string<charT,traits,Allocator> temp(lhs);
805
temp.append(rhs);
806
return temp;
807
}
808
809
810
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_string<charT,traits,Allocator>
811
operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs)
812
{
813
basic_string<charT,traits,Allocator> temp(1, lhs);
814
temp.append(rhs);
815
return temp;
816
}
817
818
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_string<charT,traits,Allocator>
819
operator+(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs)
820
{
821
basic_string<charT,traits,Allocator> temp(lhs);
822
temp.append(rhs);
823
return temp;
824
}
825
826
template<class charT, class traits, class Allocator> _UCXXEXPORT basic_string<charT,traits,Allocator>
827
operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs)
828
{
829
basic_string<charT,traits,Allocator> temp(lhs);
830
temp+=rhs;
831
return temp;
832
}
833
834
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
835
operator==(const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs)
836
{
837
if(lhs.compare(rhs) == 0){
838
return true;
839
}
840
return false;
841
}
842
843
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
844
operator==(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs)
845
{
846
if(rhs.compare(lhs) == 0){
847
return true;
848
}
849
return false;
850
}
851
852
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
853
operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs)
854
{
855
if(lhs.compare(rhs)==0){
856
return true;
857
}
858
return false;
859
}
860
861
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
862
operator!=(const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs)
863
{
864
if(lhs.compare(rhs) !=0){
865
return true;
866
}
867
return false;
868
}
869
870
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
871
operator!=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs)
872
{
873
basic_string<charT,traits,Allocator> temp(lhs);
874
return (temp != rhs);
875
}
876
877
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
878
operator!=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs)
879
{
880
basic_string<charT,traits,Allocator> temp(rhs);
881
return (lhs != temp);
882
}
883
884
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
885
operator< (const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs)
886
{
887
if(lhs.compare(rhs) < 0){
888
return true;
889
}
890
return false;
891
}
892
893
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
894
operator< (const basic_string<charT,traits,Allocator>& lhs, const charT* rhs)
895
{
896
basic_string<charT,traits,Allocator> temp(rhs);
897
if(lhs.compare(rhs) < 0){
898
return true;
899
}
900
return false;
901
}
902
903
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
904
operator< (const charT* lhs, const basic_string<charT,traits,Allocator>& rhs)
905
{
906
basic_string<charT,traits,Allocator> temp(lhs);
907
if(temp.compare(rhs) < 0){
908
return true;
909
}
910
return false;
911
}
912
913
914
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
915
operator> (const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs)
916
{
917
if(lhs.compare(rhs) > 0){
918
return true;
919
}
920
return false;
921
}
922
923
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
924
operator> (const basic_string<charT,traits,Allocator>& lhs, const charT* rhs)
925
{
926
basic_string<charT,traits,Allocator> temp(rhs);
927
if(lhs.compare(rhs) > 0){
928
return true;
929
}
930
return false;
931
}
932
933
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
934
operator> (const charT* lhs, const basic_string<charT,traits,Allocator>& rhs)
935
{
936
basic_string<charT,traits,Allocator> temp(lhs);
937
if(temp.compare(rhs) > 0){
938
return true;
939
}
940
return false;
941
}
942
943
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
944
operator<=(const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs)
945
{
946
if(lhs.compare(rhs) <=0){
947
return true;
948
}
949
return false;
950
}
951
952
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
953
operator<=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs)
954
{
955
basic_string<charT,traits,Allocator> temp(rhs);
956
if(lhs.compare(temp) <=0 ){
957
return true;
958
}
959
return false;
960
}
961
962
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
963
operator<=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs)
964
{
965
basic_string<charT,traits,Allocator> temp(lhs);
966
if(temp.compare(rhs) <= 0){
967
return true;
968
}
969
return false;
970
}
971
972
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
973
operator>=(const basic_string<charT,traits,Allocator>& lhs, const basic_string<charT,traits,Allocator>& rhs)
974
{
975
if(lhs.compare(rhs) >=0){
976
return true;
977
}
978
return false;
979
}
980
981
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
982
operator>=(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs)
983
{
984
basic_string<charT,traits,Allocator> temp(rhs);
985
if(lhs.compare(temp) >=0 ){
986
return true;
987
}
988
return false;
989
}
990
991
template<class charT, class traits, class Allocator> _UCXXEXPORT bool
992
operator>=(const charT* lhs, const basic_string<charT,traits,Allocator>& rhs)
993
{
994
basic_string<charT,traits,Allocator> temp(lhs);
995
if(temp.compare(rhs) >=0 ){
996
return true;
997
}
998
return false;
999
}
1000
1001
template<class charT, class traits, class Allocator> _UCXXEXPORT void
1002
swap(basic_string<charT,traits,Allocator>& lhs, basic_string<charT,traits,Allocator>& rhs)
1003
{
1004
lhs.swap(rhs);
1005
}
1006
1007
/*template<class charT, class traits, class Allocator> _UCXXEXPORT basic_ostream<charT, traits>&
1008
operator<<(basic_ostream<charT, traits>& os, const basic_string<charT,traits,Allocator>& str)
1009
{
1010
return os.write(str.data(), str.length());
1011
}*/
1012
1013
#ifdef __UCLIBCXX_EXPAND_STRING_CHAR__
1014
#ifndef __UCLIBCXX_COMPILE_STRING__
1015
1016
//Operators we can avoid duplication of
1017
1018
template <> _UCXXEXPORT bool operator==(const string & lhs, const string & rhs);
1019
template <> _UCXXEXPORT bool operator==(const char * lhs, const string & rhs);
1020
template <> _UCXXEXPORT bool operator==(const string & lhs, const char * rhs);
1021
1022
template <> _UCXXEXPORT bool operator!=(const string & lhs, const string & rhs);
1023
template <> _UCXXEXPORT bool operator!=(const char * lhs, const string & rhs);
1024
template <> _UCXXEXPORT bool operator!=(const string & lhs, const char * rhs);
1025
1026
template <> _UCXXEXPORT string operator+(const string & lhs, const char* rhs);
1027
template <> _UCXXEXPORT string operator+(const char* lhs, const string & rhs);
1028
template <> _UCXXEXPORT string operator+(const string & lhs, const string & rhs);
1029
1030
template <> _UCXXEXPORT bool operator> (const string & lhs, const string & rhs);
1031
template <> _UCXXEXPORT bool operator< (const string & lhs, const string & rhs);
1032
1033
1034
#endif
1035
#endif
1036
1037
1038
}
1039
1040
#pragma GCC visibility pop
1041
1042
#endif
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0