BasicString.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2009  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_BasicString_hxx
#define __ccxx_BasicString_hxx

#include <commonc++/Common.h++>
#include <commonc++/AtomicCounter.h++>
#include <commonc++/Blob.h++>
#include <commonc++/Char.h++>
#include <commonc++/CharsetConverter.h++>
#include <commonc++/CharTraits.h++>
#include <commonc++/OutOfBoundsException.h++>

#include <string>
#include <vector>
#include <sstream>
#include <cerrno>

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#endif // _MSC_VER

namespace ccxx {

template<typename T> class BasicStringVec; // fwd ref

template<typename T> class BasicString
{
  public:

  BasicString();

  BasicString(T *str, size_t offset = 0, size_t length = 0,
              bool copy = true);

  BasicString(const BasicString<T>& other);

  BasicString(const T *other, size_t offset = 0, size_t length = 0);

  BasicString(const byte_t *data, size_t length, const char *encoding);

  virtual ~BasicString() throw();

  bool endsWith(const BasicString<T> &str, bool ignoreCase = false)
    const throw();

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

  bool endsWithAnyOf(const T *chars, bool ignoreCase = false) const throw();

  bool startsWith(const BasicString<T> &str, bool ignoreCase = false)
    const throw();

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

  bool startsWithAnyOf(const T *chars, bool ignoreCase = false) const throw();

  size_t getLength() const throw();

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

  void setLength(uint_t length);

  void reserve(uint_t capacity);

  size_t getCapacity() const throw();

  void compact();

  inline BasicString<T>& clear()
  {
    setLength(0);
    return(*this);
  }

  bool isEmpty() const throw();

  bool isNull() const throw();

  bool isAlphaNumeric() const throw();

  bool isInteger() const throw();

  int compareTo(const T *other, bool ignoreCase = false) const throw();

  int compareTo(const BasicString<T> &other, bool ignoreCase = false) const
    throw();

  BasicString<T>& trim(const T *chars = whitespaceChars, bool begin = true,
                       bool end = true);

  inline BasicString<T>& trimBegin(const T *chars = whitespaceChars)
  { return(trim(chars, true, false)); }

  inline BasicString<T>& trimEnd(const T *chars = whitespaceChars)
  { return(trim(chars, false, true)); }

  BasicString<T>& chop(T c);

  BasicString<T>& reverseChop(T c);

  BasicString<T>& replace(T a, T b);

  inline BasicString<T>& replace(const BasicString<T> &a,
                                 const BasicString<T> &b)
  { return(replace(a.c_str(), b.c_str())); }

  BasicString<T>& replace(const T *a, const T *b);

  BasicString<T>& printf(const T *format, ...);

  BasicString<T>& insert(T c, uint_t index = 0);

  BasicString<T>& insert(const T *str, uint_t index = 0, size_t length = 0);

  BasicString<T>& insert(const BasicString<T>& str, uint_t index = 0,
                         size_t length = 0);

  inline BasicString<T>& insert(const std::basic_string<T> &str,
                                uint_t index = 0, size_t length = 0)
  { return(insert(str.c_str(), index, length)); }

  BasicString<T>& append(bool v);

  BasicString<T>& append(int val);

  BasicString<T>& append(int val, uint_t base);

  BasicString<T>& append(uint_t val);

  BasicString<T>& append(uint_t val, uint_t base);

  BasicString<T>& append(int64_t val);

  BasicString<T>& append(double val, uint_t precision = 6);

  BasicString<T>& append(uint64_t val);

  inline BasicString<T>& append(T c)
  { return(insert(c, END)); }

  inline BasicString<T>& append(const T *str, size_t length = 0)
  { return(insert(str, END, length)); }

  inline BasicString<T>& append(const BasicString<T> &str,
                                size_t length = 0)
  { return(insert(str, END, length)); }

  inline BasicString<T>& append(const std::basic_string<T> &str,
                                size_t length = 0)
  { return(insert(str.c_str(), END, length)); }

  inline BasicString<T>& prepend(T c)
  { return(insert(c, 0)); }

  inline BasicString<T>& prepend(const T *str, size_t length = 0)
  { return(insert(str, 0, length)); }

  inline BasicString<T>& prepend(const BasicString<T>& str, size_t length = 0)
  { return(insert(str, 0, length)); }

  inline BasicString<T>& prepend(const std::basic_string<T> &str,
                                 size_t length = 0)
  { return(insert(str.c_str(), 0, length)); }

  BasicString<T>& remove(uint_t fromIndex, uint_t toIndex = END);

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

  BasicString<T> substring(uint_t fromIndex, uint_t toIndex = END) const;

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

  int indexOf(const T *str, uint_t fromIndex = 0) const throw();

  int indexOfAnyOf(const T *chars, uint_t fromIndex = 0) const throw();

  inline int indexOf(const BasicString<T>& str, uint_t fromIndex = 0) const
    throw()
  { return(indexOf(str.c_str(), fromIndex)); }

  inline int indexOf(const std::basic_string<T> &str, uint_t fromIndex = 0)
    const throw()
  { return(indexOf(str.c_str(), fromIndex)); }

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

  int lastIndexOfAnyOf(const T *chars, uint_t fromIndex = END) const throw();

  int lastIndexOf(const T *str, uint_t fromIndex = END) const throw();

  inline int lastIndexOf(const BasicString<T> &str, uint_t fromIndex = END)
    const throw()
  { return(lastIndexOf(str.c_str(), fromIndex)); }

  inline int lastIndexOf(const std::basic_string<T> &str,
                         uint_t fromIndex = END) const throw()
  { return(lastIndexOf(str.c_str(), fromIndex)); }

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

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

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

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

  inline bool contains(const std::basic_string<T> &str) const throw()
  { return(indexOf(str) >= 0); }

  BasicString<T> nextToken(uint_t &fromIndex,
                           const T *delim = whitespaceChars) const;

  uint_t split(BasicStringVec<T> &tokens, const T *delim = whitespaceChars,
               uint_t limit = 0) const;

  BasicString<T>& toLowerCase();

  BasicString<T>& toUpperCase();

  BasicString<T>& fill(T c, size_t length);

  BasicString<T>& pad(T c, size_t length);

  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 T * c_str() const throw();

  Blob getBytes(const char *encoding, size_t length = 0,
                size_t maxEncodedLength = 0) const;

  BasicString<T>& operator=(const T *other);

  BasicString<T>& operator=(const BasicString<T> &other);

  inline BasicString<T>& operator=(const std::basic_string<T> &other)
  { return(operator=(other.c_str())); }

  T& operator[](int index) throw(OutOfBoundsException);

  BasicChar<T> operator[](int index) const throw(OutOfBoundsException);

  inline BasicString<T> operator()(uint_t fromIndex, uint_t toIndex = END)
    const
  { return(substring(fromIndex, toIndex)); }

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

  inline BasicString<T>& operator+=(T c)
  { return(append(c)); }

  inline BasicString<T>& operator+=(const T *str)
  { return(append(str)); }

  inline BasicString<T>& operator+=(const BasicString<T> &str)
  { return(append(str)); }

  inline BasicString<T>& operator+=(const std::basic_string<T> &str)
  { return(append(str.c_str())); }

  inline BasicString<T>& operator+=(bool val)
  { return(append(val)); }

  inline BasicString<T>& operator+=(int val)
  { return(append(val)); }

  inline BasicString<T>& operator+=(uint_t val)
  { return(append(val)); }

  inline BasicString<T>& operator+=(double val)
  { return(append(val)); }

  inline BasicString<T>& operator+=(int64_t val)
  { return(append(val)); }

  inline BasicString<T>& operator+=(uint64_t val)
  { return(append(val)); }

  inline BasicString<T>& operator<<(const T *str)
  { return(append(str)); }

  inline BasicString<T>& operator<<(const BasicString<T> &str)
  { return(append(str)); }

  inline BasicString<T>& operator<<(const std::basic_string<T> &str)
  { return(append(str)); }

  inline BasicString<T>& operator<<(bool val)
  { return(append(val)); }

  inline BasicString<T>& operator<<(T c)
  { return(append(c)); }

  inline BasicString<T>& operator<<(int val)
  { return(append(val)); }

  inline BasicString<T>& operator<<(uint_t val)
  { return(append(val)); }

  inline BasicString<T>& operator<<(int64_t val)
  { return(append(val)); }

  inline BasicString<T>& operator<<(uint64_t val)
  { return(append(val)); }

  inline BasicString<T>& operator<<(double val)
  { return(append(val)); }

  inline BasicString<T>& operator^=(T c)
  { return(prepend(c)); }

  inline BasicString<T>& operator^=(const T *str)
  { return(prepend(str)); }

  inline BasicString<T>& operator^=(const BasicString<T> &str)
  { return(prepend(str)); }

  inline BasicString<T>& operator^=(const std::basic_string<T> &str)
  { return(prepend(str)); }

  BasicString<T> operator+(const BasicString<T> &str);
  BasicString<T> operator+(const T *str);
  BasicString<T> operator+(T c);

  static BasicString<T> fromCharArray(const char *str, size_t length = 0);

  static BasicString<T> fromUTF8(const char *str);

  static BasicString<T> fromWCharArray(const wchar_t *str, size_t length = 0);

  static const uint_t END;

  static const BasicString<T> null;

  static const BasicString<T> empty;

  static const T *whitespaceChars;

  private:

  class StringBuf
  {
    friend class BasicString<T>;

    protected:

    T *_data;
    size_t _capacity;
    size_t _length;
    AtomicCounter _refs;

    StringBuf(const StringBuf& other, size_t length);
    StringBuf(T *str = NULL, size_t offset = 0, size_t length = 0,
              bool copy = true);
    StringBuf(const T *str, size_t offset = 0, size_t length = 0);
    ~StringBuf() throw();

    void reserve(size_t size);
    void compact();
    void makeNull();
    void makeCopy(const T *str, size_t offset, size_t length);

    private:

    CCXX_COPY_DECLS(StringBuf);
  };

  StringBuf *_buf;

  void _release();
  void _makeCopy(size_t size, bool unshareable = false);
  T *_makeGap(uint_t index, size_t gaplen);
  void _encode(const byte_t *data, size_t length, const char *encoding);
};

template<typename T> class BasicStringVec
  : public std::vector<BasicString<T> >
{
  public:

  BasicStringVec()
  { }

  inline BasicStringVec<T>& operator<<(BasicString<T> s)
  { push_back(s); return(*this); }

  static const BasicStringVec<T> emptyVec;
};

template<typename T>
  inline bool operator==(const BasicString<T> &s1, const BasicString<T> &s2)
  throw()
{ return(s1.compareTo(s2) == 0); }

template<typename T>
  inline bool operator==(const BasicString<T> &s1, const T *s2) throw()
{ return(s1.compareTo(s2) == 0); }

template<typename T>
  inline bool operator==(const T *s1, const BasicString<T> &s2) throw()
{ return(s2.compareTo(s1) == 0); }

template<typename T>
  inline bool operator!=(const BasicString<T> &s1, const BasicString<T> &s2)
  throw()
{ return(s1.compareTo(s2) != 0); }

template<typename T>
  inline bool operator!=(const BasicString<T> &s1, const T *s2) throw()
{ return(s1.compareTo(s2) != 0); }

template<typename T>
  inline bool operator!=(const T *s1, const BasicString<T> &s2) throw()
{ return(s2.compareTo(s1) != 0); }

template<typename T>
  inline bool operator<(const BasicString<T> &s1, const BasicString<T> &s2)
  throw()
{ return(s1.compareTo(s2) < 0); }

template<typename T>
  inline bool operator<(const BasicString<T> &s1, const T *s2) throw()
{ return(s1.compareTo(s2) < 0); }

template<typename T>
  inline bool operator<(const T *s1, const BasicString<T> &s2) throw()
{ return(s2.compareTo(s1) > 0); }

template<typename T>
  inline bool operator>(const BasicString<T> &s1, const BasicString<T> &s2)
  throw()
{ return(s1.compareTo(s2) > 0); }

template<typename T>
  inline bool operator>(const BasicString<T> &s1, const T *s2) throw()
{ return(s1.compareTo(s2) > 0); }

template<typename T>
  inline bool operator>(const T *s1, const BasicString<T> &s2) throw()
{ return(s2.compareTo(s1) < 0); }

template<typename T>
  inline bool operator<=(const BasicString<T> &s1, const BasicString<T> &s2)
  throw()
{ return(s1.compareTo(s2) <= 0); }

template<typename T>
  inline bool operator<=(const BasicString<T> &s1, const T *s2) throw()
{ return(s1.compareTo(s2) <= 0); }

template<typename T>
  inline bool operator<=(const T *s1, const BasicString<T> &s2) throw()
{ return(s2.compareTo(s1) > 0); }

template<typename T>
  inline bool operator>=(const BasicString<T> &s1, const BasicString<T> &s2)
  throw()
{ return(s1.compareTo(s2) >= 0); }

template<typename T>
  inline bool operator>=(const BasicString<T> &s1, const T *s2) throw()
{ return(s1.compareTo(s2) >= 0); }

template<typename T>
  inline bool operator>=(const T *s1, const BasicString<T> &s2) throw()
{ return(s2.compareTo(s1) < 0); }

template<typename T>
  inline BasicString<T> operator+(const T *s1, const BasicString<T> &s2)
{ return(BasicString<T>(s1) + s2); }

template<typename T>
  inline BasicString<T> operator+(T c, const BasicString<T> &s)
{ BasicString<T> t; t += c; t += s; return(t); }

template<typename T>
  inline std::ostream& operator<<(std::ostream& stream,
                                  const BasicString<T> &s)
{ return(stream << (s ? s.c_str() : BasicCharTraits<T>::nullRep())); }

#include <commonc++/BasicStringImpl.h++>

}; // namespace ccxx

#ifdef _MSC_VER
#pragma warning(pop)
#endif // _MSC_VER

#endif // __ccxx_BasicString_hxx

/* end of header file */