Char.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  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_Char_hxx
#define __ccxx_Char_hxx

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

namespace ccxx {

class COMMONCPP_API Char
{
 public:

  Char();

  explicit Char(char c);

  explicit Char(char16_t c);

  Char(int c);

  ~Char();

  Char& operator=(char c);

  Char& operator=(char16_t c);

  Char& operator=(int c);

  bool isNul() const;

  bool isControl() const;

  bool isPrintable() const;

  bool isGraphical() const;

  bool isPunctuation() const;

  bool isLetter() const;

  bool isDigit() const;

  bool isHexDigit() const;

  bool isAlphabetic() const;

  bool isAlphaNumeric() const;

  bool isSign() const;

  bool isWhitespace() const;

  bool isLowerCase() const;

  bool isUpperCase() const;

  Char toLowerCase() const;

  Char toUpperCase() const;

  bool isASCII() const;

  bool isLowASCII() const;

  bool isHighASCII() const;

  bool isLowSurrogate() const;

  bool isHighSurrogate() const;

  char16_t toChar16() const
  { return(_char); }

  char toASCII() const;

  bool operator==(const Char& other) const
  { return(_char == other._char); }

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

  bool operator!=(const Char& other) const
  { return(_char != other._char); }

  bool operator<(const Char& other) const
  { return(_char < other._char); }

  bool operator>(const Char& other) const
  { return(_char > other._char); }

  bool operator<=(const Char& other) const
  { return(_char <= other._char); }

  bool operator>=(const Char& other) const
  { return(_char >= other._char); }

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

  inline Char& operator++()
  {
    ++_char;
    return(*this);
  }

  inline Char operator++(int)
  { return(Char(_char++)); }

  inline Char& operator--()
  {
    --_char;
    return(*this);
  }

  inline Char operator--(int)
  { return(Char(_char--)); }

  static const Char nul;

  static const Char BELL;

  static const Char BACKSPACE;

  static const Char TAB;

  static const Char NEWLINE;

  static const Char VERTICAL_TAB;

  static const Char FORM_FEED;

  static const Char RETURN;

  static const Char ESCAPE;

  static const Char SPACE;

  static const Char DELETE;

  static bool isNul(char16_t c);

  static bool isControl(char16_t c);

  static bool isPrintable(char16_t c);

  static bool isGraphical(char16_t c);

  static bool isPunctuation(char16_t c);

  static bool isLetter(char16_t c);

  static bool isDigit(char16_t c);

  static bool isHexDigit(char16_t c);

  static bool isAlphabetic(char16_t c);

  static bool isAlphaNumeric(char16_t c);

  static bool isSign(char16_t c);

  static bool isWhitespace(char16_t c);

  static bool isLowerCase(char16_t c);

  static bool isUpperCase(char16_t c);

  static char16_t toLowerCase(char16_t c);

  static char16_t toUpperCase(char16_t c);

  static bool isASCII(char16_t c);

  static bool isLowASCII(char16_t c);

  static bool isHighASCII(char16_t c);

  static bool isLowSurrogate(char16_t c);

  static bool isHighSurrogate(char16_t c);

  static char toASCII(char16_t c);

 private:

  char16_t _char;
};

inline bool operator==(char c1, const Char& c2)
{ return(static_cast<char16_t>(c1) == c2.toChar16()); }

inline bool operator!=(char c1, const Char& c2)
{ return(static_cast<char16_t>(c1) != c2.toChar16()); }

inline bool operator<(char c1, const Char& c2)
{ return(static_cast<char16_t>(c1) < c2.toChar16()); }

inline bool operator<=(char c1, const Char& c2)
{ return(static_cast<char16_t>(c1) <= c2.toChar16()); }

inline bool operator>(char c1, const Char& c2)
{ return(static_cast<char16_t>(c1) > c2.toChar16()); }

inline bool operator>=(char c1, const Char& c2)
{ return(static_cast<char16_t>(c1) >= c2.toChar16()); }

inline bool operator==(char16_t c1, const Char& c2)
{ return(c1 == c2.toChar16()); }

inline bool operator!=(char16_t c1, const Char& c2)
{ return(c1 != c2.toChar16()); }

inline bool operator<(char16_t c1, const Char& c2)
{ return(c1 < c2.toChar16()); }

inline bool operator<=(char16_t c1, const Char& c2)
{ return(c1 <= c2.toChar16()); }

inline bool operator>(char16_t c1, const Char& c2)
{ return(c1 > c2.toChar16()); }

inline bool operator>=(char16_t c1, const Char& c2)
{ return(c1 >= c2.toChar16()); }

} // namespace ccxx

#endif // __ccxx_Char_hxx