UString.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  Mark A Lindner

   This file is part of commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_UString_hxx
#define __ccxx_UString_hxx

#include <commonc++/Common.h++>
#include <commonc++/AtomicCounter.h++>
#include <commonc++/UChar.h++>
#include <commonc++/CharRef.h++>
#include <commonc++/CString.h++>
#include <commonc++/Hash.h++>
#include <commonc++/OutOfBoundsException.h++>

#include <string>
#include <vector>
#include <cerrno>
#include <iosfwd>

#include <stdio.h> // remove

namespace ccxx {

class UStringVec;

class COMMONCPP_API UString
{
  public:

  UString();

  UString(char16_t *str, uint_t offset = 0, uint_t count = 0,
          bool copy = true);

  UString(const char16_t *str, uint_t offset = 0, uint_t count = 0);

  UString(const char *str, uint_t offset = 0, uint_t count = 0);

  UString(const UString &other);

  ~UString() throw();

  bool endsWith(const UString &str, bool ignoreCase = false) const throw();

  bool endsWith(const UChar &c, bool ignoreCase = false) const throw();

  bool endsWithAnyOf(const UString &chars, bool ignoreCase = false) const
    throw();

  bool startsWith(const UString &str, bool ignoreCase = false) const throw();

  bool startsWith(const UChar &c, bool ignoreCase = false) const throw();

  bool startsWithAnyOf(const UString &chars, bool ignoreCase = false)
    const throw();

  uint_t getLength() const throw();

  inline uint_t length() const throw()
  { return(getLength()); }

  void setLength(uint_t length);

  void reserve(uint_t capacity);

  uint_t getCapacity() const throw();

  void compact();

  inline UString& clear()
  {
    setLength(0);
    return(*this);
  }

  bool isEmpty() const throw();

  bool isNull() const throw();

  bool isInteger() const throw();

  int compareTo(const UString &other, bool ignoreCase = false) const throw();

  UString& trim(const UString &chars = whitespaceChars, bool begin = true,
               bool end = true);

  inline UString& trimBegin(const UString &chars = whitespaceChars)
  { return(trim(chars, true, false)); }

  inline UString& trimEnd(const UString &chars = whitespaceChars)
  { return(trim(chars, false, true)); }

  UString& chop(const UChar &c);

  UString& reverseChop(const UChar &c);

  UString& replace(const UChar &a, const UChar &b);

  UString& replace(const UString &a, const UString &b);

  UString& insert(const UChar &c, uint_t index = 0);

  UString& insert(const UString &str, uint_t index = 0, uint_t length = 0);

  UString& insert(const char16_t *str, uint_t index = 0, uint_t count = 0);

  inline UString& insert(const char *str, uint_t index = 0,
                         uint_t count = 0)
  { return(insert(UString(str), index, count)); }

  UString& append(bool v);

  inline UString& append(char c)
  { return(append(UChar(c))); }

  UString& append(int val);

  UString& append(int val, uint_t base);

  UString& append(uint_t val);

  UString& append(uint_t val, uint_t base);

  UString& append(const int64_t &val);

  UString& append(const double &val, uint_t precision = 6);

  UString& append(const uint64_t &val);

  inline UString& append(const UChar &c)
  { return(insert(c, END)); }

  inline UString& append(const UString &str, uint_t count = 0)
  { return(insert(str, END, count)); }

  inline UString& append(const char16_t *str, uint_t count = 0)
  { return(insert(str, END, count)); }

  inline UString& append(const char *str, uint_t count = 0)
  { return(insert(UString(str), END, count)); }

  inline UString& prepend(const UChar &c)
  { return(insert(c, 0)); }

  inline UString& prepend(const UString &str, uint_t count = 0)
  { return(insert(str, 0, count)); }

  inline UString& prepend(const char16_t *str, uint_t count = 0)
  { return(insert(str, 0, count)); }

  inline UString& prepend(const char *str, uint_t count = 0)
  { return(insert(UString(str), 0, count)); }

  UString& remove(uint_t fromIndex, uint_t toIndex = END);

  UString& setCharAt(uint_t index, const UChar &c) throw(OutOfBoundsException);

  uint_t hash(uint_t modulo = 256) const throw();

  UString substring(uint_t fromIndex, uint_t toIndex = END) const;

  int indexOf(const UChar& c, uint_t fromIndex = 0) const throw();

  inline int indexOf(const char *str, uint_t fromIndex = 0) const throw()
  { return(indexOf(UString(str), fromIndex)); }

  int indexOfAnyOf(const UString &chars, uint_t fromIndex = 0) const throw();

  int indexOf(const UString &str, uint_t fromIndex = 0) const throw();

  int lastIndexOf(const UChar &c, uint_t fromIndex = END) const throw();

  int lastIndexOfAnyOf(const UString &chars, uint_t fromIndex = END) const
    throw();

  int lastIndexOf(const UString &str, uint_t fromIndex = END) const throw();

  inline bool contains(const UChar &c) const throw()
  { return(indexOf(c) >= 0); }

  inline bool contains(const UString &str) const throw()
  { return(indexOf(str) >= 0); }

  inline bool containsAnyOf(const char *chars) const throw()
  { return(indexOfAnyOf(chars) >= 0); }

  UString nextToken(uint_t &fromIndex, const UString &delim = whitespaceChars)
    const;

  uint_t split(UStringVec &tokens, const UString &delim = whitespaceChars,
               uint_t limit = 0) const;

  UString& toLowerCase();

  UString& toUpperCase();

  UString& fill(const UChar &c, uint_t count);

  UString& pad(const UChar &c, uint_t count);

  bool toBool(uint_t index = 0) const throw();

  int toInt(uint_t index = 0, uint_t base = 10) const throw();

  uint_t toUInt(uint_t index = 0, uint_t base = 10) const throw();

  int64_t toInt64(uint_t index = 0, uint_t base = 10) const throw();

  uint64_t toUInt64(uint_t index = 0, uint_t base = 10) const throw();

  float toFloat(uint_t index = 0) const throw();

  double toDouble(uint_t index = 0) const throw();

  operator const void *() const throw();

  const char16_t* data() const throw();

  CString toUTF8() const;

  UString& operator=(const char *other);

  UString& operator=(const UString &other);

  inline UString& operator=(const std::string &other)
  { return(operator=(other.c_str())); }

  CharRef operator[](int index) throw(OutOfBoundsException);

  const UChar operator[](int index) const throw(OutOfBoundsException);

  inline UString operator()(uint_t fromIndex, uint_t toIndex = END) const
  { return(substring(fromIndex, toIndex)); }

  inline bool operator!() const throw()
  { return(isNull()); }

  inline UString& operator+=(const UChar &c)
  { return(append(c)); }

  inline UString& operator+=(const char *str)
  { return(append(str)); }

  inline UString& operator+=(const UString &str)
  { return(append(str)); }

  inline UString& operator+=(bool val)
  { return(append(val)); }

  inline UString& operator+=(int val)
  { return(append(val)); }

  inline UString& operator+=(uint_t val)
  { return(append(val)); }

  inline UString& operator+=(double val)
  { return(append(val)); }

  inline UString& operator+=(int64_t val)
  { return(append(val)); }

  inline UString& operator+=(uint64_t val)
  { return(append(val)); }

  inline UString& operator<<(const char *str)
  { return(append(str)); }

  inline UString& operator<<(const UString &str)
  { return(append(str)); }

  inline UString& operator<<(bool val)
  { return(append(val)); }

  inline UString& operator<<(const UChar &c)
  { return(append(c)); }

  inline UString& operator<<(int val)
  { return(append(val)); }

  inline UString& operator<<(uint_t val)
  { return(append(val)); }

  inline UString& operator<<(const int64_t &val)
  { return(append(val)); }

  inline UString& operator<<(const uint64_t &val)
  { return(append(val)); }

  inline UString& operator<<(const double &val)
  { return(append(val)); }

  inline UString& operator^=(const UChar &c)
  { return(prepend(c)); }

  inline UString& operator^=(const char *str)
  { return(prepend(str)); }

  inline UString& operator^=(const UString &str)
  { return(prepend(str)); }

  UString operator+(const UString &str);
  UString operator+(const char *str);
  UString operator+(const UChar &c);

  void write(std::ostream& stream) const;

  static const uint_t END;

  static const UString null;

  static const UString empty;

  static const UString whitespaceChars;

  private:

  class StringBuf;

  StringBuf* _buf;

  void _insert(const char16_t *str, uint_t length, uint_t index, uint_t count);
  void _release();
  void _makeCopy(size_t size, bool unshareable = false);
  char16_t* _makeGap(uint_t index, uint_t gaplen);
  void _fromUTF8(const char *str, uint_t len, uint_t offset);
};

class UStringVec : public std::vector<UString>
{
  public:

  UStringVec()
  { }

  inline UStringVec& operator<<(UString s)
  { push_back(s); return(*this); }

  static const UStringVec emptyVec;
};

inline bool operator==(const UString &s1, const UString &s2) throw()
{ return(s1.compareTo(s2) == 0); }

inline bool operator==(const UString &s1, const char *s2) throw()
{ return(s1.compareTo(s2) == 0); }

inline bool operator==(const char *s1, const UString &s2) throw()
{ return(s2.compareTo(s1) == 0); }

inline bool operator!=(const UString &s1, const UString &s2) throw()
{ return(s1.compareTo(s2) != 0); }

inline bool operator!=(const UString &s1, const char *s2) throw()
{ return(s1.compareTo(s2) != 0); }

inline bool operator!=(const char *s1, const UString &s2) throw()
{ return(s2.compareTo(s1) != 0); }

inline bool operator<(const UString &s1, const UString &s2) throw()
{ return(s1.compareTo(s2) < 0); }

inline bool operator<(const UString &s1, const char *s2) throw()
{ return(s1.compareTo(s2) < 0); }

inline bool operator<(const char *s1, const UString &s2) throw()
{ return(s2.compareTo(s1) > 0); }

inline bool operator>(const UString &s1, const UString &s2) throw()
{ return(s1.compareTo(s2) > 0); }

inline bool operator>(const UString &s1, const char *s2) throw()
{ return(s1.compareTo(s2) > 0); }

inline bool operator>(const char *s1, const UString &s2) throw()
{ return(s2.compareTo(s1) < 0); }

inline bool operator<=(const UString &s1, const UString &s2) throw()
{ return(s1.compareTo(s2) <= 0); }

inline bool operator<=(const UString &s1, const char *s2) throw()
{ return(s1.compareTo(s2) <= 0); }

inline bool operator<=(const char *s1, const UString &s2) throw()
{ return(s2.compareTo(s1) > 0); }

inline bool operator>=(const UString &s1, const UString &s2) throw()
{ return(s1.compareTo(s2) >= 0); }

inline bool operator>=(const UString &s1, const char *s2) throw()
{ return(s1.compareTo(s2) >= 0); }

inline bool operator>=(const char *s1, const UString &s2) throw()
{ return(s2.compareTo(s1) < 0); }

inline UString operator+(const char *s1, const UString &s2)
{ return(UString(s1) + s2); }

inline UString operator+(const UChar &c, const UString &s)
{ UString t; t += c; t += s; return(t); }

inline std::ostream& operator<<(std::ostream &stream, const UString &s)
{ s.write(stream); return(stream); }

} // namespace ccxx

#endif // __ccxx_String_hxx