keyboard_bindings.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "keyboard_key.hpp"
#include "../URL.hpp"
#include "../architecture.hpp"
#include "../command.hpp"
#include "../subsystem.hpp"
#include <unordered_map>
#include <tuple>
 
namespace hi::inline v1 {
 
class keyboard_bindings {
    struct commands_t {
        std::vector<command> system = {};
 
        std::vector<command> ignored = {};
 
        std::vector<command> user = {};
 
        std::vector<command> cache = {};
 
        [[nodiscard]] std::vector<command> const &get_commands() const noexcept
        {
            return cache;
        }
 
        void add_system_command(command cmd) noexcept
        {
            hilet i = std::find(system.cbegin(), system.cend(), cmd);
            if (i == system.cend()) {
                system.push_back(cmd);
                update_cache();
            }
        }
 
        void add_ignored_command(command cmd) noexcept
        {
            hilet i = std::find(ignored.cbegin(), ignored.cend(), cmd);
            if (i == ignored.cend()) {
                ignored.push_back(cmd);
                update_cache();
            }
        }
 
        void add_user_command(command cmd) noexcept
        {
            hilet i = std::find(user.cbegin(), user.cend(), cmd);
            if (i == user.cend()) {
                user.push_back(cmd);
                update_cache();
            }
        }
 
        void update_cache() noexcept
        {
            cache.reserve(ssize(system) + ssize(user));
 
            for (hilet cmd : system) {
                hilet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i == cache.cend()) {
                    cache.push_back(cmd);
                }
            }
 
            for (hilet cmd : ignored) {
                hilet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i != cache.cend()) {
                    cache.erase(i);
                }
            }
 
            for (hilet cmd : user) {
                hilet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i == cache.cend()) {
                    cache.push_back(cmd);
                }
            }
        }
    };
 
    std::unordered_map<keyboard_key, commands_t> bindings;
 
public:
    keyboard_bindings() noexcept : bindings() {}
 
    void add_system_binding(keyboard_key key, command command) noexcept
    {
        bindings[key].add_system_command(command);
    }
 
    void add_ignored_binding(keyboard_key key, command command) noexcept
    {
        bindings[key].add_ignored_command(command);
    }
 
    void add_user_binding(keyboard_key key, command command) noexcept
    {
        bindings[key].add_user_command(command);
    }
 
    [[nodiscard]] std::vector<command> const &translate(keyboard_key key) const noexcept
    {
        static std::vector<command> empty_commands = {};
 
        hilet i = bindings.find(key);
        if (i != bindings.cend()) {
            return i->second.get_commands();
        } else {
            return empty_commands;
        }
    }
 
    void clear() noexcept
    {
        bindings.clear();
    }
 
    void load_bindings(URL url, bool system_binding = false);
 
    // void save_user_bindings(URL url);
};
 
} // namespace hi::inline v1