Trying yet another scheme, back to a stream wrapper but with mixins this time.

engine/NBCore/SmartStreams.hpp

@@ -4,14 +4,68 @@
 
 #include <array>
 #include <iostream>
+#include <memory>
 #include <string>
+#include <sstream>
 #include <type_traits>
-#include <unordered_map>
+#include <utility>
+#include <vector>
 
 namespace nb {
 
+template <typename StreamType, typename... Mixins>
+class SmartStream;
+
+template<typename C, typename T, typename... Mixins>
+class SmartStream<std::basic_ostream<C, T>, Mixins...> : public virtual Mixins... {
+    using StreamType = std::basic_ostream<C, T>;
+protected:
+    StreamType* const _stream;
+    
+public:
+    SmartStream(StreamType& stream) : _stream(&stream) {}
+
+    StreamType* getStream() const { return _stream; }
+
+    using Mixins::process...;
+    
+    template <typename U, typename StreamFmt=SmartStream<StreamType, Mixins...>>
+    static void process(SmartStream& stream, const U& val, StreamFmt* fmtas=nullptr) {
+        *(stream._stream) << val;
+    }
+
+    template <typename ST, typename U, typename... Mixes>
+    friend SmartStream<ST, Mixes...>& operator<<(SmartStream<ST, Mixes...>& stream, const U& val) {
+        SmartStream<ST, Mixes...>::process(stream, val);
+        return stream;
+    }
+};
+
+struct SmartText {
+    int x;
+};
+
+struct SmartStreamFormatter {
+    template <typename StreamType, typename... M>
+    static void process(SmartStream<StreamType, M...>& stream, const SmartText& val, StreamType* fmtas = nullptr) {
+        *(stream.getStream()) << val.x;
+    }
+};
+
+}
+/*namespace nb {
+
 using RGB = std::array<unsigned char, 3>;
 
+class TerminalBufferController {
+    
+    template <typename T>
+    friend void switchCoutBuf(T);
+private:
+    static auto terminal_buffer = std::cout.rdbuf();
+    TerminalBufferController();
+};
+
 std::string toANSI(const RGB& color) {
     return "\x1b[38;2;"+std::to_string(color[0])+";"+std::to_string(color[1])+
         ";"+std::to_string(color[2])+"m";
@@ -21,46 +75,116 @@ std::string toANSI(const unsigned int& color) {
     return "\x1b[38;5;"+std::to_string(color)+"m";
 }
 
-template <typename U, typename Derived=void>
+template <typename T>
-struct SmartText {
+void switchCoutBuf(T val) {
-    SmartText(const U& val) : msg(val) {}
 
-    const U msg;
+}
+
+/* class TextStream {
+    virtual void write(std::)
+};
+
+struct SmartTextBase {
+    virtual std::string toString(std::ostream&) const = 0;
+    virtual ~SmartTextBase() = default;
+};
+
+template <typename U, typename Derived=void>
+struct SmartText;
+
+template <typename U, typename Derived>
+struct SmartText<U, Derived> : SmartTextBase {
+    explicit SmartText(const U& val) : msg(val) {}
+
+    SmartText(const SmartText&) = default;
 
     template<typename C, typename T>
-    void process(std::basic_ostream<C,T>& stream) const;
+    std::string toString(std::basic_ostream<C,T>& stream) const {
+        return static_cast<const Derived&>(*this).toString(stream);
+    }
+    std::string toString(std::ostream& stream) const override {
+        return static_cast<const Derived&>(*this).toString(stream);
+    }
+
+    U msg;
+};
+
+template <typename U>
+struct SmartText<U, void> : SmartTextBase {
+    explicit SmartText(const U& val) : msg(val) {}
+
+    SmartText(const SmartText&) = default;
+
+    template<typename C, typename T>
+    std::string toString(std::basic_ostream<C,T>& stream) const {
+        std::stringstream sstr;
+        auto stream_buf = stream.rdbuf(sstr.rdbuf());
+        stream << msg;
+        stream.rdbuf(stream_buf);
+        return sstr.str();
+    }
+    std::string toString(std::ostream& stream) const override {
+        std::stringstream sstr;
+        auto stream_buf = stream.rdbuf(sstr.rdbuf());
+        stream << msg;
+        stream.rdbuf(stream_buf);
+        return sstr.str();
+    }
+
+    U msg;
 };
 
 template <typename Derived>
-struct SmartText<std::string, Derived> {
+struct SmartText<std::string, Derived> : SmartTextBase {
     template <std::size_t N>
     SmartText(char const(&val) [N]) : msg(val) {}
     SmartText(const std::string& val) : msg(val) {}
     SmartText(const char* val) : msg(val) {}
     
-    const std::string msg;
+    SmartText(const SmartText&) = default;
 
     template<typename C, typename T>
-    void process(std::basic_ostream<C,T>& stream) const;
+    std::string toString(std::basic_ostream<C,T>& stream) const {
+        return static_cast<const Derived&>(*this).toString(stream);
+    }
+    std::string toString(std::ostream& stream) const override {
+        return static_cast<const Derived&>(*this).toString(stream);
+    }
+
+    std::string msg;
 };
 
-template <typename U, typename Derived>
+template <>
+struct SmartText<std::string, void> : SmartTextBase {
+    template <std::size_t N>
+    SmartText(char const(&val) [N]) : msg(val) {}
+    SmartText(const std::string& val) : msg(val) {}
+    SmartText(const char* val) : msg(val) {}
+    
+    SmartText(const SmartText&) = default;
+
     template<typename C, typename T>
-void SmartText<U,Derived>::process(std::basic_ostream<C,T>& stream) const {
+    std::string toString(std::basic_ostream<C,T>& stream) const {
-    if (std::is_void<Derived>::value) {
+        std::stringstream sstr;
+        auto stream_buf = stream.rdbuf(sstr.rdbuf());
         stream << msg;
-    } else {
+        stream.rdbuf(stream_buf);
-        static_cast<Derived*>(this)->process(stream);
+        return sstr.str();
     }
+    std::string toString(std::ostream& stream) const override {
+        std::stringstream sstr;
+        auto stream_buf = stream.rdbuf(sstr.rdbuf());
+        stream << msg;
+        stream.rdbuf(stream_buf);
+        return sstr.str();
     }
 
-template<typename C, typename T, typename U, typename D>
+    std::string msg;
-std::basic_ostream<C, T>& operator<<(std::basic_ostream<C, T>& stream, const SmartText<U,D>& smt) {
+};
-    if (std::is_void<D>::value) {
+
-        stream << smt.msg;
+template<typename C, typename T>
-    } else {
+std::basic_ostream<C, T>& operator<<(std::basic_ostream<C, T>& stream, const SmartTextBase& smt) {
-        static_cast<const D*>(&smt)->process(stream);
+    stream << smt.toString(stream);
-    }
     return stream;
 }
 
@@ -74,19 +198,78 @@ struct TerminalColor : public SmartText<U, TerminalColor<U>> {
     explicit TerminalColor(const RGB& color, const U& val) 
         : Base(val), colorSequence(toANSI(color)) { }
 
+    TerminalColor(const TerminalColor&) = default;
+
     const std::string colorSequence;
 
     template <typename C, typename T>
-    void process(std::basic_ostream<C, T>& stream) const {
+    std::string toString(std::basic_ostream<C, T>& stream) const {
+        std::stringstream sstr;
+        auto stream_buf = stream.rdbuf(sstr.rdbuf());
         if (&stream == &std::cout) {
             stream << colorSequence << msg << "\x1b[0m";
         } else {
             stream << msg;
         }
+        stream.rdbuf(stream_buf);
+        return sstr.str();
     }
 };
 
-
+template <typename T, typename U>
+std::vector<std::shared_ptr<T>> variadicToBaseVec(std::vector<std::shared_ptr<T>> vec, const U& val) {
+    static_assert(std::is_base_of<T, U>::value, "Push value type must be base of vector base type.");
+    vec.push(static_cast<std::shared_ptr<T>>(std::make_shared(val)));
+    return vec;
 }
 
+template <typename T, typename... U>
+std::vector<std::shared_ptr<T>> variadicToBaseVec(std::vector<std::shared_ptr<T>> vec, const U&... val) {
+    vec.push(static_cast<std::shared_ptr<T>>(std::make_shared(val...)));
+    return variadicToBaseVec<T, U...>(vec, val...);
+}
+
+struct SmartGroup : public SmartText<std::vector<std::shared_ptr<SmartTextBase>>, SmartGroup> {
+    using SmartVec = std::vector<std::shared_ptr<SmartTextBase>>;
+    typedef SmartText<SmartVec, SmartGroup> Base;
+    using Base::msg;
+
+    SmartGroup(const SmartGroup&) = default;
+
+    template<typename... Types>
+    explicit SmartGroup(const Types&... vals)
+        : Base(variadicToBaseVec<SmartTextBase, Types...>({}, vals...)) {}
+
+    template <typename T>
+    void push(const T& val) {
+        msg = variadicToBaseVec(msg, val);
+    }
+
+    template <typename T>
+    SmartGroup operator+(const T& val) {
+        SmartGroup ret(*this);
+        ret.push(val);
+        return ret;
+    }
+
+    template <typename C, typename T>
+    std::string toString(std::basic_ostream<C, T>& stream) const {
+        std::stringstream sstr;
+        auto stream_buf = stream.rdbuf(sstr.rdbuf());
+        for (const std::shared_ptr<SmartTextBase>& st : msg) {
+            stream << st;
+        }
+        stream.rdbuf(stream_buf);
+        return sstr.str();
+    }
+
+};
+
+template <typename lU, typename lD, typename rU, typename rD>
+SmartGroup operator+(const SmartText<lU, lD>& lhs, const SmartText<rU, rD>& rhs) {
+    return SmartGroup(lhs, rhs);
+}
+
+} */
+
 #endif // _NB_SMARTSTREAM

engine/NBCore/tests/SmartStreamTest/main.cpp

@@ -10,7 +10,10 @@
 
 int main() {
 
-    auto test = nb::TerminalColor(9, 2030);
+    nb::SmartStream<decltype(std::cout), nb::SmartStreamFormatter> stout(std::cout);
+
+    stout << nb::SmartText{5} << "\ngoop\n";
+/*     nb::SmartText test(100);
 
     std::cout << test;    
 
@@ -19,7 +22,7 @@ int main() {
     if (file.is_open()) {
         file << test;
     }
-    file.close();
+    file.close(); */
 
     return 0;
 }