From 4a9ce6e2555dfaf9155fa279f25667350377f688 Mon Sep 17 00:00:00 2001
From: Daniil Rozanov <dev@rozanov.info>
Date: Sat, 15 Mar 2025 18:03:23 +0400
Subject: feat: chtype wrap

---
 include/ncurses/utils/flags.hpp | 156 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 include/ncurses/utils/flags.hpp

(limited to 'include/ncurses/utils/flags.hpp')

diff --git a/include/ncurses/utils/flags.hpp b/include/ncurses/utils/flags.hpp
new file mode 100644
index 0000000..69b7aa9
--- /dev/null
+++ b/include/ncurses/utils/flags.hpp
@@ -0,0 +1,156 @@
+#ifndef INCLUDE_NCURSES_FLAGS_HPP_
+#define INCLUDE_NCURSES_FLAGS_HPP_
+
+#include <type_traits>
+
+#include <ncurses/utils/preamble.hpp>
+
+namespace NCURSES_CPP_NAMESPACE {
+
+template <typename FlagBitsType> struct is_bitmask : public std::false_type {};
+
+template <typename BitType, typename std::enable_if<is_bitmask<BitType>::value,
+                                                    bool>::type = true>
+class flags {
+public:
+  using mask_type = typename std::underlying_type<BitType>::type;
+
+  // constructors
+  NCURSES_CPP_CONSTEXPR flags() NCURSES_CPP_NOEXCEPT : mask_(0) {}
+
+  NCURSES_CPP_CONSTEXPR flags(BitType bit) NCURSES_CPP_NOEXCEPT
+      : mask_(static_cast<mask_type>(bit)) {}
+
+  NCURSES_CPP_CONSTEXPR
+  flags(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT = default;
+
+  NCURSES_CPP_CONSTEXPR explicit flags(mask_type flags) : mask_(flags) {}
+
+  // relational operators
+
+#define NCURSES_CPP_RELATIONAL(op)                                             \
+  NCURSES_CPP_CONSTEXPR bool operator op(flags<BitType> const &rhs)            \
+      const NCURSES_CPP_NOEXCEPT {                                             \
+    return mask_ op rhs.mask_;                                                 \
+  }
+
+#define NCURSES_CPP_BITWISE(op)                                                \
+  NCURSES_CPP_CONSTEXPR flags<BitType> operator op(flags<BitType> const &rhs)  \
+      const NCURSES_CPP_NOEXCEPT {                                             \
+    return flags<BitType>(mask_ op rhs.mask_);                                 \
+  }
+
+#define NCURSES_CPP_ASSIGNMENT(op)                                             \
+  NCURSES_CPP_CONSTEXPR_14 flags<BitType> &operator op##=(                     \
+      flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT {                        \
+    mask_ op## = rhs.mask_;                                                    \
+    return *this;                                                              \
+  }
+
+  NCURSES_CPP_RELATIONAL(<)
+  NCURSES_CPP_RELATIONAL(<=)
+  NCURSES_CPP_RELATIONAL(>)
+  NCURSES_CPP_RELATIONAL(>=)
+  NCURSES_CPP_RELATIONAL(==)
+  NCURSES_CPP_RELATIONAL(!=)
+
+  // logical operator
+  NCURSES_CPP_CONSTEXPR bool operator!() const NCURSES_CPP_NOEXCEPT {
+    return !mask_;
+  }
+
+  // bitwise operators
+  NCURSES_CPP_BITWISE(&)
+  NCURSES_CPP_BITWISE(|)
+  NCURSES_CPP_BITWISE(^)
+
+  /*NCURSES_CPP_CONSTEXPR flags<BitType> operator~() const {*/
+  /*  return flags<BitType>(m_mask ^ is_bitmask<BitType>::allflags.m_mask);*/
+  /*}*/
+
+  // assignment operators
+  NCURSES_CPP_CONSTEXPR_14 flags<BitType> &
+  operator=(flags<BitType> const &rhs) NCURSES_CPP_NOEXCEPT = default;
+
+  NCURSES_CPP_ASSIGNMENT(&)
+  NCURSES_CPP_ASSIGNMENT(|)
+  NCURSES_CPP_ASSIGNMENT(^)
+
+  // cast operators
+  explicit NCURSES_CPP_CONSTEXPR operator bool() const NCURSES_CPP_NOEXCEPT {
+    return !!mask_;
+  }
+
+  explicit NCURSES_CPP_CONSTEXPR
+  operator mask_type() const NCURSES_CPP_NOEXCEPT {
+    return mask_;
+  }
+
+#undef NCURSES_CPP_RELATIONAL
+#undef NCURSES_CPP_BITWISE
+#undef NCURSES_CPP_ASSIGNMENT
+
+#if defined(NCURSES_CPP_FLAGS_MASK_TYPE_AS_PUBLIC)
+public:
+#else
+private:
+#endif
+  mask_type mask_;
+};
+
+// TODO:const BitType& - link may be not as good as copy
+#define NPP_DEF_GLOB_OP(type_arg, op)                                          \
+  template <typename BitType,                                                  \
+            typename std::enable_if<is_bitmask<BitType>::value, bool>::type =  \
+                true>                                                          \
+  NCURSES_CPP_CONSTEXPR_INLINE type_arg operator op(                           \
+      const BitType &bit, flags<BitType> const &flags) NCURSES_CPP_NOEXCEPT {  \
+    return flags.operator op(bit);                                             \
+  }
+
+#define NPP_DEF_GLOB_BITTYPE(op)                                               \
+  template <typename BitType,                                                  \
+            typename std::enable_if<is_bitmask<BitType>::value, bool>::type =  \
+                true>                                                          \
+  NCURSES_CPP_CONSTEXPR_INLINE flags<BitType> operator op(                     \
+      BitType lhs, BitType rhs) NCURSES_CPP_NOEXCEPT {                         \
+    return flags<BitType>(lhs) op rhs;                                         \
+  }
+
+#define NPP_DEF_GLOB_OP_BOOL(op) NPP_DEF_GLOB_OP(bool, op)
+#define NPP_DEF_GLOB_OP_FLAG(op) NPP_DEF_GLOB_OP(flags<BitType>, op)
+
+#if !defined(NCURSES_CPP_HAS_SPACESHIP_OPERATOR)
+// relational operators only needed for pre C++20
+NPP_DEF_GLOB_OP_BOOL(<)
+NPP_DEF_GLOB_OP_BOOL(<=)
+NPP_DEF_GLOB_OP_BOOL(>)
+NPP_DEF_GLOB_OP_BOOL(>=)
+NPP_DEF_GLOB_OP_BOOL(==)
+NPP_DEF_GLOB_OP_BOOL(!=)
+#endif
+
+NPP_DEF_GLOB_OP_FLAG(&)
+NPP_DEF_GLOB_OP_FLAG(|)
+NPP_DEF_GLOB_OP_FLAG(^)
+
+// bitwise operators on BitType
+NPP_DEF_GLOB_BITTYPE(&)
+NPP_DEF_GLOB_BITTYPE(|)
+NPP_DEF_GLOB_BITTYPE(^)
+
+#undef NPP_DEF_GLOB_OP
+#undef NPP_DEF_GLOB_OP_BOOL
+#undef NPP_DEF_GLOB_OP_FLAG
+#undef NPP_DEF_GLOB_BITTYPE
+
+template <typename BitType,
+          typename std::enable_if<is_bitmask<BitType>::value>::type>
+NCURSES_CPP_CONSTEXPR_INLINE flags<BitType>
+operator~(BitType bit) NCURSES_CPP_NOEXCEPT {
+  return ~(flags<BitType>(bit));
+}
+
+} // namespace NCURSES_CPP_NAMESPACE
+
+#endif // INCLUDE_NCURSES_FLAGS_HPP_
-- 
cgit v1.2.3