Cross Reference: /external/lzma/CPP/Common/MyString.h

Lines Matching defs:const
26 inline unsigned MyStringLen(const char *s)

33 inline void MyStringCopy(char *dest, const char *src)

38 inline char *MyStpCpy(char *dest, const char *src)

51 inline unsigned MyStringLen(const wchar_t *s)

58 inline void MyStringCopy(wchar_t *dest, const wchar_t *src)

64 inline wchar_t *MyWcpCpy(wchar_t *dest, const wchar_t *src)

78 int FindCharPosInString(const char *s, char c) throw();

79 int FindCharPosInString(const wchar_t *s, wchar_t c) throw();

167 bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw();

169 bool IsString1PrefixedByString2(const char *s1, const char *s2) throw();

170 bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw();

171 bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) throw();

173 int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw();

174 // int MyStringCompareNoCase_N(const wchar_t *s1, const wchar_t *s2, unsigned num) throw();

178 bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw();

179 bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw();

180 bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw();

181 bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw();

205   // AString(unsigned num, const char *s);

206   AString(unsigned num, const AString &s);

207   AString(const AString &s, char c); // it's for String + char

208   AString(const char *s1, unsigned num1, const char *s2, unsigned num2);

210   friend AString operator+(const AString &s, char c) { return AString(s, c); } ;

211   // friend AString operator+(char c, const AString &s); // is not supported

213   friend AString operator+(const AString &s1, const AString &s2);

214   friend AString operator+(const AString &s1, const char    *s2);

215   friend AString operator+(const char    *s1, const AString &s2);

221   void Find(wchar_t c) const;

222   void Find(wchar_t c, unsigned startIndex) const;

223   void ReverseFind(wchar_t c) const;

231   AString(const char *s);

232   AString(const AString &s);

235   unsigned Len() const { return _len; }

236   bool IsEmpty() const { return _len == 0; }

239   operator const char *() const { return _chars; }

240   const char *Ptr() const { return _chars; }

241   const char *Ptr(unsigned pos) const { return _chars + pos; }

242   const char *RightPtr(unsigned num) const { return _chars + _len - num; }

243   char Back() const { return _chars[_len - 1]; }

276   AString &operator=(const char *s);

277   AString &operator=(const AString &s);

278   void SetFromWStr_if_Ascii(const wchar_t *s);

298   AString &operator+=(const char *s);

299   AString &operator+=(const AString &s);

300   void AddAscii(const char *s) { operator+=(s); }

302   void SetFrom(const char *s, unsigned len); // no check

303   void SetFrom_CalcLen(const char *s, unsigned len);

304   // void SetFromAscii(const char *s) { operator+=(s); }

306   AString Mid(unsigned startIndex, unsigned count) const { return AString(count, _chars + startIndex); }

307   AString Left(unsigned count) const { return AString(count, *this); }

314   bool IsEqualTo(const char *s) const { return strcmp(_chars, s) == 0; }

315   bool IsEqualTo_Ascii_NoCase(const char *s) const { return StringsAreEqualNoCase_Ascii(_chars, s); }

316   // int Compare(const char *s) const { return MyStringCompare(_chars, s); }

317   // int Compare(const AString &s) const { return MyStringCompare(_chars, s._chars); }

318   // int CompareNoCase(const char *s) const { return MyStringCompareNoCase(_chars, s); }

319   // int CompareNoCase(const AString &s) const { return MyStringCompareNoCase(_chars, s._chars); }

320   bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }

321   bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();

323   bool IsAscii() const

326     const char *s = _chars;

332   int Find(char c) const { return FindCharPosInString(_chars, c); }

333   int Find(char c, unsigned startIndex) const

339   int ReverseFind(char c) const throw();

340   int ReverseFind_Dot() const throw() { return ReverseFind('.'); }

341   int ReverseFind_PathSepar() const throw();

343   int Find(const char *s) const { return Find(s, 0); }

344   int Find(const char *s, unsigned startIndex) const throw();

356   void Insert(unsigned index, const char *s);

357   void Insert(unsigned index, const AString &s);

362   void Replace(const AString &oldString, const AString &newString);

378 bool operator<(const AString &s1, const AString &s2);

379 bool operator>(const AString &s1, const AString &s2);

382 bool operator==(const AString &s1, const AString &s2);

383 bool operator==(const AString &s1, const char    *s2);

384 bool operator==(const char    *s1, const AString &s2);

386 bool operator!=(const AString &s1, const AString &s2);

387 bool operator!=(const AString &s1, const char    *s2);

388 bool operator!=(const char    *s1, const AString &s2);

391 inline bool operator==(const AString &s1, const AString &s2) { return s1.Len() == s2.Len() && strcmp(s1, s2) == 0; }

392 inline bool operator==(const AString &s1, const char    *s2) { return strcmp(s1, s2) == 0; }

393 inline bool operator==(const char    *s1, const AString &s2) { return strcmp(s1, s2) == 0; }

395 inline bool operator!=(const AString &s1, const AString &s2) { return s1.Len() != s2.Len() || strcmp(s1, s2) != 0; }

396 inline bool operator!=(const AString &s1, const char    *s2) { return strcmp(s1, s2) != 0; }

397 inline bool operator!=(const char    *s1, const AString &s2) { return strcmp(s1, s2) != 0; }

401 void operator==(char c1, const AString &s2);

402 void operator==(const AString &s1, char c2);

404 void operator+(char c, const AString &s); // this function can be OK, but we don't use it

406 void operator+(const AString &s, int c);

407 void operator+(const AString &s, unsigned c);

408 void operator+(int c, const AString &s);

409 void operator+(unsigned c, const AString &s);

410 void operator-(const AString &s, int c);

411 void operator-(const AString &s, unsigned c);

433   UString(unsigned num, const wchar_t *s); // for Mid

434   UString(unsigned num, const UString &s); // for Left

435   UString(const UString &s, wchar_t c); // it's for String + char

436   UString(const wchar_t *s1, unsigned num1, const wchar_t *s2, unsigned num2);

438   friend UString operator+(const UString &s, wchar_t c) { return UString(s, c); } ;

439   // friend UString operator+(wchar_t c, const UString &s); // is not supported

441   friend UString operator+(const UString &s1, const UString &s2);

442   friend UString operator+(const UString &s1, const wchar_t *s2);

443   friend UString operator+(const wchar_t *s1, const UString &s2);

453   void Find(char c) const;

454   void Find(unsigned char c) const;

455   void Find(char c, unsigned startIndex) const;

456   void Find(unsigned char c, unsigned startIndex) const;

457   void ReverseFind(char c) const;

458   void ReverseFind(unsigned char c) const;

469   UString(const wchar_t *s);

470   UString(const UString &s);

473   unsigned Len() const { return _len; }

474   bool IsEmpty() const { return _len == 0; }

477   operator const wchar_t *() const { return _chars; }

478   const wchar_t *Ptr() const { return _chars; }

479   const wchar_t *Ptr(unsigned pos) const { return _chars + pos; }

480   const wchar_t *RightPtr(unsigned num) const { return _chars + _len - num; }

481   wchar_t Back() const { return _chars[_len - 1]; }

511   UString &operator=(const wchar_t *s);

512   UString &operator=(const UString &s);

532   UString &operator+=(const wchar_t *s);

533   UString &operator+=(const UString &s);

535   void SetFrom(const wchar_t *s, unsigned len); // no check

537   void SetFromAscii(const char *s);

538   void AddAscii(const char *s);

540   UString Mid(unsigned startIndex, unsigned count) const { return UString(count, _chars + startIndex); }

541   UString Left(unsigned count) const { return UString(count, *this); }

548   bool IsEqualTo(const char *s) const { return StringsAreEqual_Ascii(_chars, s); }

549   bool IsEqualTo_NoCase(const wchar_t *s) const { return StringsAreEqualNoCase(_chars, s); }

550   bool IsEqualTo_Ascii_NoCase(const char *s) const { return StringsAreEqualNoCase_Ascii(_chars, s); }

551   int Compare(const wchar_t *s) const { return wcscmp(_chars, s); }

552   // int Compare(const UString &s) const { return MyStringCompare(_chars, s._chars); }

553   // int CompareNoCase(const wchar_t *s) const { return MyStringCompareNoCase(_chars, s); }

554   // int CompareNoCase(const UString &s) const { return MyStringCompareNoCase(_chars, s._chars); }

555   bool IsPrefixedBy(const wchar_t *s) const { return IsString1PrefixedByString2(_chars, s); }

556   bool IsPrefixedBy_NoCase(const wchar_t *s) const { return IsString1PrefixedByString2_NoCase(_chars, s); }

557   bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();

559   bool IsAscii() const

562     const wchar_t *s = _chars;

568   int Find(wchar_t c) const { return FindCharPosInString(_chars, c); }

569   int Find(wchar_t c, unsigned startIndex) const

575   int ReverseFind(wchar_t c) const throw();

576   int ReverseFind_Dot() const throw() { return ReverseFind(L'.'); }

577   int ReverseFind_PathSepar() const throw();

579   int Find(const wchar_t *s) const { return Find(s, 0); }

580   int Find(const wchar_t *s, unsigned startIndex) const throw();

592   void Insert(unsigned index, const wchar_t *s);

593   void Insert(unsigned index, const UString &s);

598   void Replace(const UString &oldString, const UString &newString);

614 bool operator<(const UString &s1, const UString &s2);

615 bool operator>(const UString &s1, const UString &s2);

617 inline bool operator==(const UString &s1, const UString &s2) { return s1.Len() == s2.Len() && wcscmp(s1, s2) == 0; }

618 inline bool operator==(const UString &s1, const wchar_t *s2) { return wcscmp(s1, s2) == 0; }

619 inline bool operator==(const wchar_t *s1, const UString &s2) { return wcscmp(s1, s2) == 0; }

621 inline bool operator!=(const UString &s1, const UString &s2) { return s1.Len() != s2.Len() || wcscmp(s1, s2) != 0; }

622 inline bool operator!=(const UString &s1, const wchar_t *s2) { return wcscmp(s1, s2) != 0; }

623 inline bool operator!=(const wchar_t *s1, const UString &s2) { return wcscmp(s1, s2) != 0; }

628 void operator==(wchar_t c1, const UString &s2);

629 void operator==(const UString &s1, wchar_t c2);

631 void operator+(wchar_t c, const UString &s); // this function can be OK, but we don't use it

633 void operator+(const UString &s, char c);

634 void operator+(const UString &s, unsigned char c);

635 void operator+(char c, const UString &s);

636 void operator+(unsigned char c, const UString &s);

637 void operator-(const UString &s1, wchar_t c);

641 void operator+(const UString &s, int c);

642 void operator+(const UString &s, unsigned c);

643 void operator+(int c, const UString &s);

644 void operator+(unsigned c, const UString &s);

645 void operator-(const UString &s1, int c);

646 void operator-(const UString &s1, unsigned c);

674   UString2(const wchar_t *s);

675   UString2(const UString2 &s);

678   unsigned Len() const { return _len; }

679   bool IsEmpty() const { return _len == 0; }

682   // operator const wchar_t *() const { return _chars; }

683   const wchar_t *GetRawPtr() const { return _chars; }

693   UString2 &operator=(const wchar_t *s);

694   UString2 &operator=(const UString2 &s);

695   void SetFromAscii(const char *s);

698 bool operator==(const UString2 &s1, const UString2 &s2);

699 bool operator==(const UString2 &s1, const wchar_t *s2);

700 bool operator==(const wchar_t *s1, const UString2 &s2);

702 inline bool operator!=(const UString2 &s1, const UString2 &s2) { return !(s1 == s2); }

703 inline bool operator!=(const UString2 &s1, const wchar_t *s2) { return !(s1 == s2); }

704 inline bool operator!=(const wchar_t *s1, const UString2 &s2) { return !(s1 == s2); }

709 void operator==(wchar_t c1, const UString2 &s2);

710 void operator==(const UString2 &s1, wchar_t c2);

711 bool operator<(const UString2 &s1, const UString2 &s2);

712 bool operator>(const UString2 &s1, const UString2 &s2);

714 void operator+(const UString2 &s1, const UString2 &s2);

715 void operator+(const UString2 &s1, const wchar_t *s2);

716 void operator+(const wchar_t *s1, const UString2 &s2);

717 void operator+(wchar_t c, const UString2 &s);

718 void operator+(const UString2 &s, wchar_t c);

719 void operator+(const UString2 &s, char c);

720 void operator+(const UString2 &s, unsigned char c);

721 void operator+(char c, const UString2 &s);

722 void operator+(unsigned char c, const UString2 &s);

723 void operator-(const UString2 &s1, wchar_t c);

757   FString fas2fs(const AString &s);

758   AString fs2fas(const FChar *s);

767   UString fs2us(const FString &s);

768   FString us2fs(const wchar_t *s);

780 typedef const FChar *CFSTR;
OpenGrok
