BasicChar.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_BasicChar_hxx
#define __ccxx_BasicChar_hxx

#include <commonc++/Common.h++>
#include <commonc++/CharTraits.h++>

namespace ccxx {

template<typename T> class BasicChar
{
  public:

  BasicChar(T c = BasicCharTraits<T>::nul())
    : _char(c)
  { }

  BasicChar(const BasicChar &other)
    : _char(other._char)
  { }

  virtual ~BasicChar() throw() { }

  inline bool isAlpha() const throw()
  { return(BasicCharTraits<T>::isAlpha(_char)); }

  inline bool isAlphaNumeric() const throw()
  { return(isAlpha() || isDigit()); }

  inline bool isWhitespace() const throw()
  { return(BasicCharTraits<T>::isWhitespace(_char)); }

  inline bool isPrintable() const throw()
  { return(BasicCharTraits<T>::isPrintable(_char)); }

  inline bool isGraphical() const throw()
  { return(BasicCharTraits<T>::isGraphical(_char)); }

  inline bool isNul() const throw()
  { return(BasicCharTraits<T>::isNul(_char)); }

  inline bool isControl() const throw()
  { return(BasicCharTraits<T>::isControl(_char)); }

  inline bool isDigit() const throw()
  { return(BasicCharTraits<T>::isDigit(_char)); }

  bool isHexDigit() const throw()
  { return(BasicCharTraits<T>::isHexDigit(_char)); }

  bool isLowerCase() const throw()
  { return(BasicCharTraits<T>::isLowerCase(_char)); }

  bool isUpperCase() const throw()
  { return(BasicCharTraits<T>::isUpperCase(_char)); }

  bool isASCII() const throw()
  { return((_char | 0x80) == 0); }

  bool isHighASCII() const throw()
  { return((_char & 0x80) != 0); }

  BasicChar<T> upperCase() const throw()
  { return(BasicChar<T>(BasicCharTraits<T>::toUpperCase(_char))); }

  BasicChar<T> lowerCase() const throw()
  { return(BasicChar<T>(BasicCharTraits<T>::toLowerCase(_char))); }

  inline BasicChar<T>& toUpperCase() throw()
  {
    _char = BasicCharTraits<T>::toUpperCase(_char);
    return(*this);
  }

  inline BasicChar<T>& toLowerCase() throw()
  {
    _char = BasicCharTraits<T>::toLowerCase(_char);
    return(*this);
  }

  inline BasicChar<T>& operator++() throw()
  {
    ++_char;
    return(*this);
  }

  inline BasicChar<T> operator++(int) throw()
  { return(BasicChar<T>(_char++)); }

  inline BasicChar<T>& operator--() throw()
  {
    --_char;
    return(*this);
  }

  inline BasicChar<T> operator--(int) throw()
  { return(BasicChar<T>(_char--)); }

  BasicChar<T>& operator=(T other) throw()
  {
    _char = other;
    return(*this);
  }

  BasicChar<T>& operator=(int other) throw()
  {
    _char = static_cast<T>(other);
    return(*this);
  }

  bool operator==(T other) const throw()
  { return(_char == other); }

  bool operator!=(T other) const throw()
  { return(_char != other); }

  bool operator<(T other) const throw()
  { return(_char < other); }

  bool operator>(T other) const throw()
  { return(_char > other); }

  bool operator<=(T other) const throw()
  { return(_char <= other); }

  bool operator>=(T other) const throw()
  { return(_char >= other); }

  bool operator==(const BasicChar<T> &other) const throw()
  { return(_char == other._char); }

  bool operator!=(const BasicChar<T> &other) const throw()
  { return(_char != other._char); }

  bool operator<(const BasicChar<T> &other) const throw()
  { return(_char < other._char); }

  bool operator>(const BasicChar<T> &other) const throw()
  { return(_char > other._char); }

  bool operator<=(const BasicChar<T> &other) const throw()
  { return(_char <= other._char); }

  bool operator>=(const BasicChar<T> &other) const throw()
  { return(_char >= other._char); }

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

  inline operator T() const throw()
  { return(toCharType()); }

  inline T toCharType() const throw()
  { return(_char); }

  static COMMONCPP_API const BasicChar<T> EndOfFile;

  static COMMONCPP_API const BasicChar<T> Bell;

  static COMMONCPP_API const BasicChar<T> Backspace;

  static COMMONCPP_API const BasicChar<T> Tab;

  static COMMONCPP_API const BasicChar<T> NewLine;

  static COMMONCPP_API const BasicChar<T> VTab;

  static COMMONCPP_API const BasicChar<T> FormFeed;

  static COMMONCPP_API const BasicChar<T> Return;

  static COMMONCPP_API const BasicChar<T> Escape;

  static COMMONCPP_API const BasicChar<T> Space;

  static COMMONCPP_API const BasicChar<T> Delete;

  private:

  char _char;
};

template<typename T> inline bool operator==(T c1, const BasicChar<T> &c2)
{ return(c1 == c2.toCharType()); }

template<typename T> inline bool operator!=(T c1, const BasicChar<T> &c2)
{ return(c1 != c2.toChar()); }

template<typename T> inline bool operator<(T c1, const BasicChar<T> &c2)
{ return(c1 < c2.toCharType()); }

template<typename T> inline bool operator<=(T c1, const BasicChar<T> &c2)
{ return(c1 <= c2.toCharType()); }

template<typename T> inline bool operator>(T c1, const BasicChar<T> &c2)
{ return(c1 > c2.toCharType()); }

template<typename T> inline bool operator>=(T c1, const BasicChar<T> &c2)
{ return(c1 >= c2.toCharType()); }

typedef BasicChar<char> Char;
typedef BasicChar<wchar_t> WChar;

}; // namespace ccxx

#endif // __ccxx_BasicChar_hxx

/* end of header file */