move iostream_operators to magic_enum_iostream

doc/reference.md

@@ -19,6 +19,7 @@
 * [`is_scoped_enum` checks whether type is an Scoped enumeration.](#is_scoped_enum)
 * [`underlying_type` improved UB-free "SFINAE-friendly" underlying_type.](#underlying_type)
 * [`ostream_operators` ostream operators for enums.](#ostream_operators)
+* [`istream_operators` istream operators for enums.](#istream_operators)
 * [`bitwise_operators` bitwise operators for enums.](#bitwise_operators)
 * [`containers::array` array container for enums.](#containersarray)
 * [`containers::bitset` bitset container for enums.](#containersbitset)
@@ -511,9 +512,10 @@ basic_ostream<Char, Traits>& operator<<(basic_ostream<Char, Traits>& os, E value
 
 template <typename Char, typename Traits, typename E>
 basic_ostream<Char, Traits>& operator<<(basic_ostream<Char, Traits>& os, optional<E> value);
-
 ```
 
+* You should add the required file `<magic_enum_iostream.hpp>`.
+
 * Out-of-the-box ostream operators for all enums.
 
 * Examples
@@ -524,6 +526,25 @@ basic_ostream<Char, Traits>& operator<<(basic_ostream<Char, Traits>& os, optiona
   std::cout << color << std::endl; // "BLUE"
   ```
 
+## `istream_operators`
+
+```cpp
+template <typename Char, typename Traits, typename E>
+basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>& is, E& value);
+```
+
+* You should add the required file `<magic_enum_iostream.hpp>`.
+
+* Out-of-the-box istream operators for all enums.
+
+* Examples
+
+  ```cpp
+  using namespace magic_enum::istream_operators; // out-of-the-box istream operators for enums.
+  Color color;
+  std::cin >> color;
+  ```
+
 ## `bitwise_operators`
 
 ```cpp

example/enum_flag_example.cpp

@@ -24,13 +24,14 @@
 #include <string>
 
 #include <magic_enum.hpp>
+#include <magic_enum_iostream.hpp>
 
 enum class AnimalFlags : std::uint64_t { HasClaws = 1 << 10, CanFly = 1 << 20, EatsFish = 1 << 30, Endangered = std::uint64_t{1} << 40 };
-// Add specialization `is_flags` to force define that enum are flags.
+// Add specialization `is_flags` to define that enum are flags.
-//template <>
+template <>
-//struct magic_enum::customize::enum_range<AnimalFlags> {
+struct magic_enum::customize::enum_range<AnimalFlags> {
-//  static constexpr bool is_flags = true;
+  static constexpr bool is_flags = true;
-//};
+};
 
 int main() {
   // Enum-flags variable to string name.
@@ -48,7 +49,7 @@ int main() {
   // AnimalFlags names: HasClaws CanFly EatsFish Endangered
 
   // String name to enum-flags value.
-  auto f2 = magic_enum::enum_cast<AnimalFlags>("EatsFish|CanFly");
+  auto f2 = magic_enum::enum_flags_cast<AnimalFlags>("EatsFish|CanFly");
   if (f2.has_value()) {
     std::cout << "EatsFish|CanFly = " << magic_enum::enum_integer(f2.value()) << std::endl; // CanFly|EatsFish = 1074790400
   }
@@ -80,7 +81,7 @@ int main() {
     std::cout << " " << f; // Ostream operator for enum-flags.
   }
   std::cout << std::endl;
-  // AnimalFlags sequence: HasClaws CanFly EatsFish Endangered
+  // AnimalFlags values: HasClaws CanFly EatsFish Endangered
 
   using namespace magic_enum::bitwise_operators; // out-of-the-box bitwise operators for all enums.
   // Support operators: ~, |, &, ^, |=, &=, ^=.

example/example.cpp

@@ -23,6 +23,7 @@
 #include <iostream>
 
 #include <magic_enum.hpp>
+#include <magic_enum_iostream.hpp>
 
 enum class Color : int { RED = -10, BLUE = 0, GREEN = 10 };
 
@@ -80,7 +81,7 @@ int main() {
     std::cout << " " << c; // Ostream operator for enum.
   }
   std::cout << std::endl;
-  // Color sequence: RED BLUE GREEN
+  // Color values: RED BLUE GREEN
 
   enum class Flags { A = 1, B = 2, C = 4, D = 8 };
   using namespace magic_enum::bitwise_operators; // out-of-the-box bitwise operators for all enums.

include/magic_enum.hpp

@@ -58,9 +58,6 @@
 #if !defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW)
 #include <string_view>
 #endif
-#if !defined(MAGIC_ENUM_NO_STREAMS)
-#include <iosfwd>
-#endif
 
 #if defined(__clang__)
 #  pragma clang diagnostic push
@@ -1467,81 +1464,6 @@ inline constexpr auto as_flags = AsFlags ? detail::enum_subtype::flags : detail:
 template <bool AsFlags = true>
 inline constexpr auto as_common = AsFlags ? detail::enum_subtype::common : detail::enum_subtype::flags;
 
-#if !defined(MAGIC_ENUM_NO_STREAMS)
-
-namespace ostream_operators {
-
-template <typename Char, typename Traits, typename E, detail::enable_if_t<E, int> = 0>
-std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, E value) {
-  using D = std::decay_t<E>;
-  using U = underlying_type_t<D>;
-
-  if constexpr (detail::supported<D>::value) {
-    if constexpr (detail::subtype_v<D> == detail::enum_subtype::flags) {
-      if (const auto name = enum_flags_name<D>(value); !name.empty()) {
-        for (const auto c : name) {
-          os.put(c);
-        }
-        return os;
-      }
-    } else {
-      if (const auto name = enum_name<D>(value); !name.empty()) {
-        for (const auto c : name) {
-          os.put(c);
-        }
-        return os;
-      }
-    }
-  }
-  return (os << static_cast<U>(value));
-}
-
-template <typename Char, typename Traits, typename E, detail::enable_if_t<E, int> = 0>
-std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, optional<E> value) {
-  return value ? (os << *value) : os;
-}
-
-} // namespace magic_enum::ostream_operators
-
-namespace istream_operators {
-
-template <typename Char, typename Traits, typename E, detail::enable_if_t<E, int> = 0>
-std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is, E& value) {
-  using D = std::decay_t<E>;
-
-  std::basic_string<Char, Traits> s;
-  is >> s;
-  if constexpr (detail::supported<D>::value) {
-    if constexpr (detail::subtype_v<D> == detail::enum_subtype::flags) {
-      if (const auto v = enum_flags_cast<D>(s)) {
-        value = *v;
-      } else {
-        is.setstate(std::basic_ios<Char>::failbit);
-      }
-    } else {
-      if (const auto v = enum_cast<D>(s)) {
-        value = *v;
-      } else {
-        is.setstate(std::basic_ios<Char>::failbit);
-      }
-    }
-  } else {
-    is.setstate(std::basic_ios<Char>::failbit);
-  }
-  return is;
-}
-
-} // namespace magic_enum::istream_operators
-
-namespace iostream_operators {
-
-using namespace ostream_operators;
-using namespace istream_operators;
-
-} // namespace magic_enum::iostream_operators
-
-#endif
-
 namespace bitwise_operators {
 
 template <typename E, detail::enable_if_t<E, int> = 0>

include/magic_enum_iostream.hpp

@@ -0,0 +1,113 @@
+//  __  __             _        ______                          _____
+// |  \/  |           (_)      |  ____|                        / ____|_     _
+// | \  / | __ _  __ _ _  ___  | |__   _ __  _   _ _ __ ___   | |   _| |_ _| |_
+// | |\/| |/ _` |/ _` | |/ __| |  __| | '_ \| | | | '_ ` _ \  | |  |_   _|_   _|
+// | |  | | (_| | (_| | | (__  | |____| | | | |_| | | | | | | | |____|_|   |_|
+// |_|  |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_|  \_____|
+//                __/ | https://github.com/Neargye/magic_enum
+//               |___/  version 0.8.2
+//
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2019 - 2023 Daniil Goncharov <neargye@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef NEARGYE_MAGIC_ENUM_IOSTREAM_HPP
+#define NEARGYE_MAGIC_ENUM_IOSTREAM_HPP
+
+#include "magic_enum.hpp"
+#include <iosfwd>
+
+namespace magic_enum {
+
+namespace ostream_operators {
+
+template <typename Char, typename Traits, typename E, detail::enable_if_t<E, int> = 0>
+std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, E value) {
+  using D = std::decay_t<E>;
+  using U = underlying_type_t<D>;
+
+  if constexpr (detail::supported<D>::value) {
+    if constexpr (detail::subtype_v<D> == detail::enum_subtype::flags) {
+      if (const auto name = enum_flags_name<D>(value); !name.empty()) {
+        for (const auto c : name) {
+          os.put(c);
+        }
+        return os;
+      }
+    } else {
+      if (const auto name = enum_name<D>(value); !name.empty()) {
+        for (const auto c : name) {
+          os.put(c);
+        }
+        return os;
+      }
+    }
+  }
+  return (os << static_cast<U>(value));
+}
+
+template <typename Char, typename Traits, typename E, detail::enable_if_t<E, int> = 0>
+std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, optional<E> value) {
+  return value ? (os << *value) : os;
+}
+
+} // namespace magic_enum::ostream_operators
+
+namespace istream_operators {
+
+template <typename Char, typename Traits, typename E, detail::enable_if_t<E, int> = 0>
+std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is, E& value) {
+  using D = std::decay_t<E>;
+
+  std::basic_string<Char, Traits> s;
+  is >> s;
+  if constexpr (detail::supported<D>::value) {
+    if constexpr (detail::subtype_v<D> == detail::enum_subtype::flags) {
+      if (const auto v = enum_flags_cast<D>(s)) {
+        value = *v;
+      } else {
+        is.setstate(std::basic_ios<Char>::failbit);
+      }
+    } else {
+      if (const auto v = enum_cast<D>(s)) {
+        value = *v;
+      } else {
+        is.setstate(std::basic_ios<Char>::failbit);
+      }
+    }
+  } else {
+    is.setstate(std::basic_ios<Char>::failbit);
+  }
+  return is;
+}
+
+} // namespace magic_enum::istream_operators
+
+namespace iostream_operators {
+
+using namespace ostream_operators;
+using namespace istream_operators;
+
+} // namespace magic_enum::iostream_operators
+
+} // namespace magic_enum
+
+#endif // NEARGYE_MAGIC_ENUM_IOSTREAM_HPP

test/test.cpp

@@ -29,6 +29,7 @@
 #define MAGIC_ENUM_RANGE_MAX 120
 #include <magic_enum.hpp>
 #include <magic_enum_fuse.hpp>
+#include <magic_enum_iostream.hpp>
 
 #include <array>
 #include <cctype>

test/test_flags.cpp

@@ -34,6 +34,7 @@
 
 #include <magic_enum.hpp>
 #include <magic_enum_fuse.hpp>
+#include <magic_enum_iostream.hpp>
 
 #include <array>
 #include <cctype>

test/test_nonascii.cpp

@@ -29,6 +29,7 @@
 #define MAGIC_ENUM_RANGE_MAX 120
 #include <magic_enum.hpp>
 #include <magic_enum_fuse.hpp>
+#include <magic_enum_iostream.hpp>
 
 #include <array>
 #include <cctype>