/elec/propeller-clock : revision 59

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

Committer: edam
Date: 2012-02-28 16:50:26 UTC
Revision ID: edam@waxworlds.org-20120228165026-pwnwo300xx2e2kg6

removed ulibc, fixed button, added text rendering

files added:
src/digital_clock_mode.cc

src/digital_clock_mode.h

src/display.cc

src/display.h

src/mode_base.h

src/text_renderer.cc

src/text_renderer.h

src/util/PString.cpp

src/util/PString.h

files removed:
src/utility

src/utility/Jamfile

src/utility/Makefile

src/utility/README.md

src/utility/StandardCplusplus.h

src/utility/algorithm

src/utility/algorithm.cpp

src/utility/associative_base

src/utility/associative_base.cpp

src/utility/basic_definitions

src/utility/bitset

src/utility/bitset.cpp

src/utility/cassert

src/utility/cctype

src/utility/cerrno

src/utility/cfloat

src/utility/char_traits

src/utility/char_traits.cpp

src/utility/climits

src/utility/clocale

src/utility/cmath

src/utility/complex

src/utility/complex.cpp

src/utility/csetjmp

src/utility/csignal

src/utility/cstdarg

src/utility/cstddef

src/utility/cstdio

src/utility/cstdlib

src/utility/cstring

src/utility/ctime

src/utility/cwchar

src/utility/cwctype

src/utility/del_op.cpp

src/utility/del_opnt.cpp

src/utility/del_opv.cpp

src/utility/del_opvnt.cpp

src/utility/deque

src/utility/deque.cpp

src/utility/eh_alloc.cpp

src/utility/eh_globals.cpp

src/utility/exception

src/utility/exception.cpp

src/utility/fstream

src/utility/fstream.cpp

src/utility/func_exception

src/utility/func_exception.cpp

src/utility/functional

src/utility/iomanip

src/utility/iomanip.cpp

src/utility/ios

src/utility/ios.cpp

src/utility/iosfwd

src/utility/iostream

src/utility/iostream.cpp

src/utility/istream

src/utility/istream.cpp

src/utility/istream_helpers

src/utility/iterator

src/utility/iterator.cpp

src/utility/iterator_base

src/utility/limits

src/utility/limits.cpp

src/utility/list

src/utility/list.cpp

src/utility/locale

src/utility/locale.cpp

src/utility/map

src/utility/map.cpp

src/utility/memory

src/utility/new

src/utility/new_handler.cpp

src/utility/new_op.cpp

src/utility/new_opnt.cpp

src/utility/new_opv.cpp

src/utility/new_opvnt.cpp

src/utility/numeric

src/utility/numeric.cpp

src/utility/ostream

src/utility/ostream.cpp

src/utility/ostream_helpers

src/utility/queue

src/utility/queue.cpp

src/utility/serstream

src/utility/set

src/utility/set.cpp

src/utility/sstream

src/utility/sstream.cpp

src/utility/stack

src/utility/stack.cpp

src/utility/stdexcept

src/utility/stdexcept.cpp

src/utility/streambuf

src/utility/streambuf.cpp

src/utility/string

src/utility/string.cpp

src/utility/string_iostream

src/utility/support

src/utility/support.cpp

src/utility/system_configuration.h

src/utility/type_traits

src/utility/typeinfo

src/utility/typeinfo.cpp

src/utility/uartbuf

src/utility/unwind-cxx.h

src/utility/utility.cpp

src/utility/utility.h

src/utility/valarray

src/utility/valarray.cpp

src/utility/vector

src/utility/vector.cpp

files renamed:
src/mode_switcher.cc => src/switcher_major_mode.cc

src/mode_switcher.h => src/switcher_major_mode.h

files modified:
arduino.mk

src/analogue_clock_mode.cc

src/button.cc

src/button.h

src/config.h

src/drawer.cc

src/drawer.h

src/major_mode.h

src/minor_mode.cc

src/minor_mode.h

src/propeller-clock.ino

src/test_mode.cc

Show diffs side-by-side

added added

removed removed

src/utility/string

This file is part of the uClibc++ Library.

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

#include <basic_definitions>

#include <char_traits>

#include <string.h>

#include <func_exception>

#include <memory>

#include <vector>

#ifdef __UCLIBCXX_HAS_WCHAR__

#include <cwchar>

#include <cwctype>

#endif

#ifndef __HEADER_STD_STRING

#define __HEADER_STD_STRING 1

#pragma GCC visibility push(default)

namespace std{

//Basic basic_string

template<class Ch, class Tr = char_traits<Ch>, class A = allocator<Ch> > class basic_string;

typedef basic_string<char> string;

#ifdef __UCLIBCXX_HAS_WCHAR__

typedef basic_string<wchar_t> wstring;

#endif

//template<class Ch, class Tr = char_traits<Ch>, class A = allocator<Ch> > class _UCXXEXPORT basic_string

template<class Ch, class Tr, class A> class basic_string

: public std::vector<Ch, A>

{

public:

typedef Tr traits_type;

typedef typename Tr::char_type value_type;

typedef A allocator_type;

typedef typename A::size_type size_type;

typedef typename A::difference_type difference_type;

typedef typename A::reference reference;

typedef typename A::const_reference const_reference;

typedef typename A::pointer pointer;

typedef typename A::const_pointer const_pointer;

typedef typename vector<Ch, A>::iterator iterator;

typedef typename vector<Ch, A>::const_iterator const_iterator;

typedef typename vector<Ch, A>::reverse_iterator reverse_iterator;

typedef typename vector<Ch, A>::const_reverse_iterator const_reverse_iterator;

static const size_type npos = (size_type)-1;

explicit _UCXXEXPORT basic_string(const A& al = A()) : vector<Ch, A>(al){ return; }

_UCXXEXPORT basic_string(const basic_string& str, size_type pos = 0, size_type n = npos, const A& al = A()); //Below

_UCXXEXPORT basic_string(const Ch* s, size_type n, const A& al = A())

: vector<Ch, A>(al)

{

if(n == npos){

__throw_out_of_range();

}

if(s > 0){

resize(n);

Tr::copy(vector<Ch, A>::data, s, vector<Ch, A>::elements);

}

_UCXXEXPORT basic_string(const Ch* s, const A& al = A()); //Below

_UCXXEXPORT basic_string(size_type n, Ch c, const A& al = A())

: vector<Ch, A>(n, c, al)

{

}

template<class InputIterator> _UCXXEXPORT basic_string(InputIterator begin, InputIterator end, const A& a = A())

: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