CUI.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/
#pragma once
 
#include <OnixS/ICE/BOE/messaging/Typification.h>
#include <OnixS/ICE/BOE/messaging/SbeMessage.h>
#include <OnixS/ICE/BOE/messaging/Utils.h>
 
#include "Book.h"
#include "Utils.h"
 
#include <sstream>
#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <chrono>
#include <iomanip>
 
#ifdef _WIN32
#include <windows.h>
#endif
 
namespace CUI {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;

struct Screen
{
    static void init()
    {
#ifdef _WIN32
        vtMode() = enableVtMode();
#endif
    }
 
    struct DeleteLast {size_t n;};
    inline static DeleteLast deleteLast(size_t n) {return {n};}
 
    inline friend std::ostream& operator<<(std::ostream& os, const DeleteLast& m)
    {
        if(vtMode()) os << "\x1b[" << m.n << "F" << "\x1b[" << m.n << "M" << std::flush;
        return os;
    }
 
    static std::ostream& reset(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[0m";
        return os;
    }
 
    static std::ostream& bold(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[1m";
        return os;
    }
 
    static std::ostream& red(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[38;2;255;64;64m";
        return os;
    }
 
    static std::ostream& green(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[38;2;0;255;64m";
        return os;
    }
 
    static std::ostream& yellow(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[38;2;255;255;64m";
        return os;
    }
 
    static std::ostream& black(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[30m";
        return os;
    }
 
    static std::ostream& onRed (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;210;120;120m";
        return os;
    }
 
    static std::ostream& onGreen (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;120;200;150m";
        return os;
    }
 
    static std::ostream& onYellow(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;235;220;160m";
        return os;
    }
 
    static std::ostream& onCyan  (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;150;210;220m";
        return os;
    }
 
    static std::ostream& onWhite (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;240;240;240m";
        return os;
    }
 
    static std::ostream& out()
    {
        return std::cout;
    }
 
    template<typename T>
    static T getInput(const T& defaultValue = {})
    {
        std::string userInput;
        std::getline(std::cin, userInput);
 
        if (userInput.empty())
            return defaultValue;
 
        return Samples::parseUserInput<T>(userInput);
    }
 
    template<typename... Args>
    static void info(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onGreen << "[INFO]" << reset << " " << append(args...) << "\n";
    }
 
    template<typename... Args>
    static void error(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onRed << "[ERROR]" << reset << " " << append(args...) << "\n";
    }
 
    template<typename... Args>
    static void warning(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onYellow << "[WARN]" << reset << " " << append(args...) << "\n";
    }
 
    template<typename... Args>
    static void trace(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onCyan << "[TRACE]" << reset << " " << append(args...)  << "\n";
    }
 
    template<typename... Args>
    static void out(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << append(args...) << std::endl;
    }
 
    static void printProgress(size_t cur, size_t total)
    {
        Guard g(mutex(), out());
 
        const size_t width = 40;
 
        if (total == 0) total = 1;
        cur = (std::min)(cur, total);
 
        const double r = double(cur) / double(total);
        const auto filled = static_cast<std::size_t>(r * width);
 
        out() << '\r' << '[' << std::string(filled, '#') << std::string(width - filled, ' ')
                  << "] " << std::setw(3) << int(r * 100) << '%' << std::flush;
 
        if (cur == total) out() << '\n';
    }
 
    enum class Direction {In, Out};
 
    static std::string toStr(Direction direction)
    {
#ifdef _WIN32
        return direction == Direction::In ? "[<-]" : "[->]";
#else
        return direction == Direction::In ? "[←]" : "[→]";
#endif
    }
 
    static void traceMsg(const std::string& sessionId, SbeMessage message, Direction direction)
    {
        Guard g(mutex(), out());
 
        out() << "\n" << bold << black << onCyan << toStr(direction) << reset << " ";
 
        out() << "[" << sessionId << "] ";
 
        const auto printMsg = [&](const auto msg)
        {
            out() << msg.toString();
 
            const auto text = formatMsg(msg);
 
            if(!text.empty())
                 out() << "\n\t" << text;
        };
 
        if (!ONIXS_ICEBOE_MESSAGING_NAMESPACE::processTypified(message, printMsg))
            out() << yellow << "Unknown message type [" << message.templateId() << "]" << reset;
 
        out() << "\n";
    }
 
    template <typename ItemType>
    static void outItems(const ItemType & items)
    {
        Guard g(mutex(), out());
 
        for (size_t index = 0; index < items.size(); ++index)
            out() << "\t" << bold << black << onGreen << "[" << (index + 1) << "]" << reset << " " << items[index].text_ << "\n";
    }
 
    template <typename ItemType>
    static void outList(const ItemType & list)
    {
        Guard g(mutex(), out());
 
        out() << "\t[";
 
        bool first = true;
        for (const auto& item : list)
        {
            if (!first)
                out() << ",";
 
            first = false;
            out() << item;
        }
 
        out() << "]\n";
    }
 
    static std::chrono::milliseconds sinceLstUpdate()
    {
        return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - lastUpdateTime());
    }
 
private:
    template<typename T>
    static void appendToStream(std::ostringstream& oss, const T& value)
    {
        oss << value;
    }
 
    template<typename T, typename... Args>
    static void appendToStream(std::ostringstream& oss, const T& value, const Args&... args)
    {
        oss << value;
        appendToStream(oss, args...);
    }
 
    template <typename... Args>
    static auto append(const Args&... args)
    {
        std::ostringstream oss;
        appendToStream(oss, args...);
        return oss.str();
    }
 
#ifdef _WIN32
    static bool enableVtMode()
    {
        const HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
        if (h == INVALID_HANDLE_VALUE)
            return false;
 
        DWORD mode = 0;
        if (!GetConsoleMode(h, &mode))
            return false;
 
        mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
 
        return SetConsoleMode(h, mode) != 0;
    }
#endif
    static bool& vtMode()
    {
        static bool value = true;
        return value;
    }
 
    using Mutex = std::recursive_mutex;
 
    struct Guard : public std::lock_guard<Mutex>
    {
         Guard(Mutex& mutex, std::ostream& s)
            : std::lock_guard<Mutex>(mutex)
            , s_(s)
        {}
 
        ~Guard()
        {
             try { s_ << reset << std::flush; } catch(...){}
             setLastUpdateTime();
        }
 
        std::ostream& s_;
    };
 
    static Mutex& mutex()
    {
        static Mutex mutex;
        return mutex;
    }
 
    static std::chrono::time_point<std::chrono::steady_clock>& lastUpdateTime()
    {
        static auto lastUpdateTime = std::chrono::steady_clock::now();
        return lastUpdateTime;
    }
 
    static void setLastUpdateTime()
    {
        lastUpdateTime() = std::chrono::steady_clock::now();
    }
};
 
using Command = std::function<void()>;

struct MenuItem
{
    MenuItem(const std::string& text, const std::string& commandText, const std::initializer_list<Command>& items)
        : text_(text)
        , commandText_(commandText)
        , commands_{items}
    {}
 
    MenuItem(const std::string& text, const std::string& commandText, const Command& command)
        : text_(text)
        , commandText_(commandText)
        , commands_{command}
    {}
 
    std::string text_;
    std::string commandText_;
 
    std::vector<Command> commands_;
};

class Menu
{
public:
    Menu(const std::initializer_list<MenuItem>& items)
        : items_{items}
    {
        Screen::init();
        outputItems();
    }

    void processRequests() const
    {
        while (!stopRequested_)
            processRequest();
    }

    void outputItems() const
    {
        Screen::info("Commands:");
        Screen::outItems(items_);
    }

    void stopRequest() noexcept
    {
        stopRequested_ = true;
    }
 
private:
    bool stopRequested_ = false;

    std::vector<MenuItem> items_;

    void processRequest() const
    {
        static const auto CommandExecutionTimeout = std::chrono::milliseconds(500);
 
        if(Screen::sinceLstUpdate() < CommandExecutionTimeout)
            return;
 
        Screen::info("Select operation to perform. Enter a choice (1 - Show options):");
 
        size_t selectedItemNumber = 0;
        while (true)
        {
            try
            {
                const auto userInput = Screen::getInput<size_t>();
                Screen::out() << Screen::deleteLast(3);
                selectedItemNumber = userInput - 1;
            }
            catch(...)
            {
                continue;
            }
 
            if(selectedItemNumber < items_.size())
                break;
 
            Screen::warning("Invalid command requested. Repeat a choice (1 - Show options):");
        }
 
        try
        {
            const auto& selectedItem = items_[selectedItemNumber];
 
            Screen::info(selectedItem.commandText_ + "...");
 
            const auto commands = selectedItem.commands_;
            for(auto command : commands)
            {
                command();
 
                if(stopRequested_)
                    return;

                std::this_thread::sleep_for(CommandExecutionTimeout);
            }
        }
        catch (const std::exception& ex)
        {
            Screen::error(ex.what());
        }
    }
 
friend struct ListViewer;
};
 
struct ListViewer
{
    template <typename EntryList, typename Print>
    static void outputItems(const EntryList& items, Print print = [](auto item){ return toStr(item);}, size_t itemsPerPage = 100)
    {
        if (items.empty())
        {
            Screen::info("[]");
            return;
        }
 
        size_t itemsToOutput = itemsPerPage;
 
        std::size_t n = 0;
        for (const auto& item : items)
        {
            if (0 == --itemsToOutput)
            {
                itemsToOutput = itemsPerPage;
 
                if (!shouldContinue())
                    return;
            }
 
            Screen::out() << "\n"
                << Screen::bold << Screen::black << Screen::onCyan << "[" << std::to_string(++n) << "]"
                << Screen::reset << " " << print(item)  << "\n";
        }
    }
 
private:
    static bool shouldContinue()
    {
        Screen::info("Press <Enter> to view next page or Enter 'q' to abort current action: ");
        const auto userInput = Screen::getInput<std::string>();
 
        return userInput.empty();
    }
};
 
}