util::ConsoleWrapper

#ifndef UTIL_CONSOLEWRAPPER_H
#define UTIL_CONSOLEWRAPPER_H

#include <functional>

namespace util
{
    class ConsoleWrapper
    {
        public:
            typedef std::function< void ( std::string ) > InputCallback;

            ConsoleWrapper( InputCallback theCallback );
            ~ConsoleWrapper();

            void Print( const std::string& line );


        private:
            void ReadInput();
            sf::Thread inputThread;
            std::string inputBuffer;
            InputCallback callback;

            void PrintLine( const std::string& line, bool clearInput );
            inline void ClearInputArea();
            inline void PrintInputArea();

            mutable sf::Mutex consoleMutex;
    };
}

#endif // UTIL_CONSOLEWRAPPER_H

#include "util/ConsoleWrapper.h"

#include <iostream>
#include <conio.h> // Okay, so not it's standard. Meh.

namespace util
{
    inline void ConsoleWrapper::ClearInputArea()
    {
        // Clear input area
        std::string back;
        for ( size_t i = 0; i < inputBuffer.length() + 2; ++i )
        {
            back += "\b \b";
        }
        std::cout << back;
    }

    inline void ConsoleWrapper::PrintInputArea()
    {
        std::cout << "> " << inputBuffer;
    }

    ConsoleWrapper::ConsoleWrapper( InputCallback theCallback )
       : inputThread( &ConsoleWrapper::ReadInput, this ),
         callback( theCallback )
    {
        inputThread.Launch();
    }

    ConsoleWrapper::~ConsoleWrapper()
    {
        inputThread.Terminate();
    }

    void ConsoleWrapper::ReadInput()
    {
        std::cout << "> ";
        while ( true )
        {
            // Get input
            for ( char c = getch(); true; c = getch() )
            {
                if ( c == '\b' )
                {
                    if ( inputBuffer.length() <= 0 )
                    {
                        continue;
                    }

                    sf::Lock lock( consoleMutex );

                    std::cout << "\b \b";
                    inputBuffer = inputBuffer.substr( 0, inputBuffer.length() - 1 );
                }
                else if ( c == '\r' or c == '\n' )
                {
                    break;
                }
                else
                {
                    sf::Lock lock( consoleMutex );

                    inputBuffer += c;
                    std::cout << c;
                }
            }

            // Handle commands
            if ( callback )
            {
                std::string tmp = inputBuffer;
                {
                    sf::Lock lock( consoleMutex );

                    ClearInputArea();
                    inputBuffer = "";
                    PrintInputArea();
                }

                callback( tmp );
            }
        }
    }

    void ConsoleWrapper::Print( const std::string& line )
    {
        PrintLine( line, false );
    }

    void ConsoleWrapper::PrintLine( const std::string& line, bool clearInput )
    {
        sf::Lock lock( consoleMutex );

        // Clear input
        ClearInputArea();
        if ( clearInput )
        {
            inputBuffer = "";
        }

        // Print output
        std::cout << line << std::endl;
        PrintInputArea();

        // Finish up
        std::cout.flush();
    }
}