char.hpp

Go to the documentation of this file.

 
#pragma once
#include <cctype>
#include <string>
#include <mpc/functional/partial.hpp>
#include <mpc/prelude.hpp>
 
namespace mpc {
  namespace detail {
    // See also:
    // https://en.cppreference.com/w/cpp/string/byte/isalnum
 
    struct isalnum_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isalnum(c))) {
        return std::isalnum(c);
      }
    };
 
    struct isalpha_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isalpha(c))) {
        return std::isalpha(c);
      }
    };
 
    struct islower_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::islower(c))) {
        return std::islower(c);
      }
    };
 
    struct isupper_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isupper(c))) {
        return std::isupper(c);
      }
    };
 
    struct isdigit_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isdigit(c))) {
        return std::isdigit(c);
      }
    };
 
    struct isxdigit_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isxdigit(c))) {
        return std::isxdigit(c);
      }
    };
 
    struct iscntrl_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::iscntrl(c))) {
        return std::iscntrl(c);
      }
    };
 
    struct isgraph_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isgraph(c))) {
        return std::isgraph(c);
      }
    };
 
    struct isspace_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isspace(c))) {
        return std::isspace(c);
      }
    };
 
    struct isblank_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isblank(c))) {
        return std::isblank(c);
      }
    };
 
    struct isprint_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::isprint(c))) {
        return std::isprint(c);
      }
    };
 
    struct ispunct_op {
      bool operator()(unsigned char c) const noexcept(noexcept(std::ispunct(c))) {
        return std::ispunct(c);
      }
    };
  } // namespace detail
 
  inline namespace cpo {
    inline constexpr partial<detail::isalnum_op> isalnum{};
    inline constexpr partial<detail::isalpha_op> isalpha{};
    inline constexpr partial<detail::islower_op> islower{};
    inline constexpr partial<detail::isupper_op> isupper{};
    inline constexpr partial<detail::isdigit_op> isdigit{};
    inline constexpr partial<detail::isxdigit_op> isxdigit{};
    inline constexpr partial<detail::iscntrl_op> iscntrl{};
    inline constexpr partial<detail::isgraph_op> isgraph{};
    inline constexpr partial<detail::isspace_op> isspace{};
    inline constexpr partial<detail::isblank_op> isblank{};
    inline constexpr partial<detail::isprint_op> isprint{};
    inline constexpr partial<detail::ispunct_op> ispunct{};
  } // namespace cpo
 
  template <class charT>
  inline std::basic_string<charT> quoted(charT s, charT delim = charT('\'')) {
    return {delim, s, delim};
  }
 
  template <class charT>
  inline auto quoted(const charT* s, charT delim = charT('"')) {
    return std::basic_string<charT>{delim} + s + delim;
  }
 
  template <class charT, class traits>
  inline auto quoted(std::basic_string_view<charT, traits> s, charT delim = charT('"')) {
    return delim + std::basic_string<charT, traits>{s} + delim;
  }
 
  template <class charT, class traits, class Allocator>
  inline auto quoted(const std::basic_string<charT, traits, Allocator>& s,
                     charT delim = charT('"')) {
    return delim + s + delim;
  }
 
  template <class charT, class traits, class Allocator>
  inline auto quoted(std::basic_string<charT, traits, Allocator>&& s, charT delim = charT('"')) {
    return delim + std::move(s) + delim;
  }
} // namespace mpc