Масштабирование системы при использовании паттерна Singleton

void sample()
{
     // всякая фигня
 
    log.pushPrinter<customPrinter>();  //<--- локальная настройка глобального объекта
 
    log << "hello!";  //<--- используем кастомный принтер
 
    log.popPrinter(); //<--- глобальный объект в исходное состояние
 
     // всякая фигня
}

// где нибудь в мейне
Printer::getInstance().setMethod<SuperPuper>();
...
 
Printer::getInstance()->print(data); //<--- клиентский код без изменений

#pragma once
 
//------------------------------------------------------------------------------------------------------//
 
#ifndef _STRING_
    #error #include <string> first
#endif
 
#ifndef _IOSTREAM_
    #error #include <iostream> first
#endif
 
#ifndef _SSTREAM_
    #error #include <sstream> first
#endif
 
//------------------------------------------------------------------------------------------------------//
 
struct cout_redirectA
{
    ~cout_redirectA() { this->off(); }
 
    cout_redirectA(std::streambuf& new_buffer): m_old(){ this->on(new_buffer); }
    cout_redirectA(): m_old() { this->on(); }
 
    void off() 
    { 
        if(!m_old)
            return;
 
        assert(std::cout);
        std::cout.flush();
        std::cout.rdbuf(m_old); 
        m_old = nullptr;
        assert(std::cout);
        assert(!m_old);
    }
    
    void on() { this->on( *get().rdbuf() ); }
 
    void on(std::streambuf& new_buffer) 
    { 
        assert(std::cout);
        std::cout.flush();
        m_old = std::cout.rdbuf(&new_buffer); 
        assert(std::cout);
        assert(m_old);
    }
 
    static std::string captureA()
    {
        assert(std::cout);
        std::stringstream ss;
        ss << std::cout.rdbuf();
        std::cout.flush();
        assert(std::cout);
        return ss.str();
    }
private:
    std::stringstream& get()
    {
        static std::stringstream ss;
        return ss;
    }
    std::streambuf* m_old;
};
 
//------------------------------------------------------------------------------------------------------//
 
struct cout_redirectW
{
    ~cout_redirectW() { this->off(); }
 
    cout_redirectW(std::wstreambuf& new_buffer): m_old() { this->on(new_buffer); }
    cout_redirectW(): m_old() { this->on(); }
 
    void off() 
    { 
        if(!m_old)
            return;
 
        assert(std::wcout);
        std::wcout.rdbuf(m_old); 
        m_old = nullptr;
        assert(std::wcout);
        assert(!m_old);
    }
    
    void on() { this->on( *get().rdbuf() ); }
 
    void on(std::wstreambuf& new_buffer) 
    { 
        assert(std::wcout);
        std::wcout.flush();
        m_old = std::wcout.rdbuf(&new_buffer); 
        assert(std::wcout);
        assert(m_old);
    }
 
    static std::wstring captureW()
    {
        assert(std::wcout);
        std::wstringstream ss;
        ss << std::wcout.rdbuf();
        std::wcout.flush();
        assert(std::wcout);
        return ss.str();
    }
private:
    std::wstringstream& get()
    {
        static std::wstringstream ss;
        return ss;
    }
    std::wstreambuf* m_old;
};
 
//------------------------------------------------------------------------------------------------------//
 
struct cout_redirect: cout_redirectA, cout_redirectW
{
    cout_redirect()
        :cout_redirectA()
        ,cout_redirectW()
    {}
 
    cout_redirect(std::streambuf& new_buffer)
        :cout_redirectA(new_buffer)
        ,cout_redirectW()
    {}
 
    cout_redirect(std::wstreambuf& new_buffer)
        :cout_redirectA()
        ,cout_redirectW(new_buffer)
    {}
 
    operator std::string()const  { return cout_redirectA::captureA(); }
    operator std::wstring()const { return cout_redirectW::captureW(); }
    void off()
    {
        cout_redirectA::off();
        cout_redirectW::off();
    }
    void on() 
    {  
        cout_redirectA::on();
        cout_redirectW::on();
    }
    using::cout_redirectA::on;
    using::cout_redirectW::on;
};
 
//------------------------------------------------------------------------------------------------------//
 
 
TEST(CASENAME_, TNUM_(sample, 005))
{
    // --- stress-test
 
    cout_redirect redirect;
    std::wcout << L"ololo\ntrololo\n";
    std::wstring captured = redirect;
    redirect.off();
    
    std::wcout <<L"captured: '"<< captured << L"'\n";
    ASSERT_TRUE(captured == L"ololo\ntrololo\n");
 
    redirect.on();
    std::wcout << L"ololo\ntrololo\n";
    std::wstring wcaptured = redirect;
    redirect.off();
    
    std::wcout <<L"captured: '"<< wcaptured << L"'\n";
    ASSERT_TRUE(wcaptured == L"ololo\ntrololo\n");
 
    redirect.on();
    std::cout << "ololo\ntrololo\n";
    std::string captured2 = redirect;
    redirect.off();
    
    std::cout <<"captured: '"<< captured2 << "'\n";
    ASSERT_TRUE(captured2 == "ololo\ntrololo\n");
}