GroupMenuModel.hpp

Go to the documentation of this file.

#ifndef IV_SRC_MODEL_DIAMAR_GROUPMENUMODEL_HPP_
#define IV_SRC_MODEL_DIAMAR_GROUPMENUMODEL_HPP_
 
#include "core/types.hpp"
#include "filehandlers/xmlFile.hpp"
 
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <map>
#include <ranges>
#include <string>
#include <utility>
#include <vector>
 
namespace iv::diamar
{
class Mimic;
}
 
namespace iv::model
{
 
enum class Type
{
    Action,
    Dropdown
};
 
template<typename T>
class ItemModel
{
public:
    ItemModel() : type(Type::Action), order(0), actionItem(T())
    {
    }
 
    ItemModel(iv::types::groupItemId _id, Type _type, std::string _label, uint8_t _order, const T &_actionItem = T())
        : id(std::move(_id)), type(_type), label(std::move(_label)), order(_order), actionItem(_actionItem)
    {
    }
 
    bool operator<(const ItemModel &other) const
    {
        return order < other.order;
    }
 
    void removeAction(const T &actionToRemove)
    {
        if (type == Type::Dropdown)
        {
            std::vector<iv::types::groupItemId> actionsToRemove;
            for (auto &[itemId, item]: subOptions)
            {
                switch (item.type)
                {
                    case Type::Action:
                        if constexpr (std::is_same_v<std::weak_ptr<typename T::element_type>, T>)
                        {
                            if (item.actionItem.lock() == actionToRemove.lock())
                            {
                                actionsToRemove.push_back(itemId);
                            }
                        }
                        else if (item.actionItem == actionToRemove)
                        {
                            actionsToRemove.push_back(itemId);
                        }
                        break;
 
                    case Type::Dropdown:
                        item.removeAction(actionToRemove);
                        break;
                }
            }
 
            for (const auto &actionId: actionsToRemove)
            {
                subOptions.erase(actionId);
            }
        }
    }
 
    [[nodiscard]] std::vector<T> flattenActions() const
    {
        std::vector<T> actions;
 
        if (type == Type::Action)
        {
            actions.push_back(actionItem);
        }
        else
        {
            std::map<iv::types::order, ItemModel<T>> orderedSubOptions;
            for (const auto &[itemId, item]: subOptions)
            {
                orderedSubOptions.emplace(item.order, item);
            }
 
            for (const auto &subOption: orderedSubOptions | std::views::values)
            {
                std::vector<T> subActions = subOption.flattenActions();
                actions.insert(std::end(actions), std::begin(subActions), std::end(subActions));
            }
        }
 
        return actions;
    }
 
    // private:
    iv::types::groupItemId id {};
    Type type;
    std::string label;
    iv::types::order order {};
    T actionItem;                                             // Holds the object associated
    std::map<iv::types::groupItemId, ItemModel<T>> subOptions;// Only for DropdownItems
};
 
template<typename T>
class GroupMenuModel
{
public:
    // Add direct action item
    void addActionItem(const iv::types::groupItemId &id, const std::string &label, const T &actionItem, uint8_t order)
    {
        ItemModel<T> action(id, Type::Action, label, order, actionItem);
        items.emplace(id, action);
    }
 
    // Add an empty dropdown item
    void addEmptyDropdownItem(const iv::types::groupItemId &id, const std::string &label, uint8_t order)
    {
        ItemModel<T> dropdown(id, Type::Dropdown, label, order);
        items.emplace(id, dropdown);
    }
 
    // Add dropdown item
    void addDropdownItem(const iv::types::groupItemId &id, const std::string &label,
                         const std::vector<ItemModel<T>> &subOptions)
    {
        ItemModel<T> dropdown(id, Type::Dropdown, label);
        dropdown.subOptions = subOptions;
        items.emplace(id, dropdown);
    }
 
    void addActionToDropdownItem(const iv::types::groupItemId &dropdownId, const iv::types::groupItemId &id,
                                 const std::string &label, const T &actionItem, uint8_t order)
    {
        if (items.contains(dropdownId) and items[dropdownId].type == Type::Dropdown)
        {
            iv::model::ItemModel<T> &dropdownItem = items[dropdownId];
            ItemModel<T> action(id, Type::Action, label, order, actionItem);
            dropdownItem.subOptions.emplace(action.id, action);
        }
        else
        {
            std::cerr << "Dropdown item with label '" << dropdownId << "' not found." << std::endl;
        }
    }
 
    // Add an option to an existing dropdown item
    void addOptionToDropdownItem(const iv::types::groupItemId &dropdownId, const ItemModel<T> &newOption)
    {
        if (items.contains(dropdownId) and items[dropdownId].type == Type::Dropdown)
        {
            iv::model::ItemModel<T> &dropdownItem = items[dropdownId];
            dropdownItem.subOptions.emplace(newOption.id, newOption);
        }
        else
        {
            std::cerr << "Dropdown item with label '" << dropdownId << "' not found." << std::endl;
        }
    }
 
    // Remove an item from the main menu
    void removeItem(const iv::types::groupItemId &itemId)
    {
        if (items.contains(itemId))
        {
            items.erase(itemId);
            std::cout << "Item '" << itemId << "' removed from the menu." << std::endl;
        }
        else
        {
            std::cerr << "Item '" << itemId << "' not found in the menu." << std::endl;
        }
    }
 
    // Remove a dropdown item (and all its options)
    void removeDropdownItem(const iv::types::groupItemId &dropdownId)
    {
        if (items.contains(dropdownId) and items[dropdownId].type == Type::Dropdown)
        {
            items.erase(dropdownId);
            std::cout << "Dropdown item '" << dropdownId << "' removed from the menu." << std::endl;
        }
        else
        {
            std::cerr << "Dropdown item '" << dropdownId << "' not found in the menu." << std::endl;
        }
    }
 
    // Remove an option from an existing dropdown item
    void removeOptionFromDropdownItem(const iv::types::groupItemId &dropdownId, const iv::types::groupItemId &optionId)
    {
        if (items.contains(dropdownId) and items[dropdownId].type == Type::Dropdown)
        {
            iv::model::ItemModel<T> &dropdownItem = items[dropdownId];
 
            if (dropdownItem.subOptions.contains(optionId))
            {
                dropdownItem.subOptions.erase(optionId);
                std::cout << "Option '" << optionId << "' removed from dropdown '" << dropdownId << "'." << std::endl;
            }
            else
            {
                std::cerr << "Option '" << optionId << "' not found in dropdown '" << dropdownId << "'." << std::endl;
            }
        }
        else
        {
            std::cerr << "Dropdown item with label '" << dropdownId << "' not found." << std::endl;
        }
    }
 
    void removeAction(const T &action)
    {
        std::vector<iv::types::groupItemId> itemsToRemove;
        for (auto &[itemId, item]: items)
        {
            switch (item.type)
            {
                case Type::Action:
                    if constexpr (std::is_same_v<std::weak_ptr<typename T::element_type>, T>)
                    {
                        if (item.actionItem.lock() == action.lock())
                        {
                            itemsToRemove.push_back(itemId);
                        }
                    }
                    else if (item.actionItem == action)
                    {
                        itemsToRemove.push_back(itemId);
                    }
                    break;
 
                case Type::Dropdown:
                    item.removeAction(action);
                    break;
            }
        }
 
        for (const auto &itemId: itemsToRemove)
        {
            items.erase(itemId);
        }
    }
 
    void collapseOptionsOrder()
    {
        std::map<std::pair<iv::types::order, iv::types::groupItemId>, iv::model::ItemModel<T> *> sortedItems;
        for (auto &[itemId, item]: items)
        {
            sortedItems.emplace(std::make_pair(item.order, itemId), &item);
        }
 
        iv::types::order optionOrder {0};
        for (const auto &[order, item]: sortedItems)
        {
            item->order = optionOrder;
            ++optionOrder;
        }
    }
 
    // List only labels of the dropdown items (roots, not the children)
    [[nodiscard]] std::vector<std::string> listDropdownLabels() const
    {
        std::vector<std::string> labels;
 
        for (const auto &item: items | std::views::values)
        {
            if (item.type == Type::Dropdown)
            {
                labels.push_back(item.label);
            }
        }
 
        return labels;
    }
 
    [[nodiscard]] std::vector<T> flattenActions() const
    {
        std::map<iv::types::order, ItemModel<T>> orderedItems;
        for (const ItemModel<T> &item: items | std::views::values)
        {
            orderedItems.emplace(item.order, item);
        }
 
        std::vector<T> actions;
        for (const auto &item: orderedItems | std::views::values)
        {
            std::vector<T> itemActions = item.flattenActions();
            actions.insert(std::end(actions), std::begin(itemActions), std::end(itemActions));
        }
 
        return actions;
    }
 
    void save(iv::file::xml::node &node) const
    {
        static_assert(sizeof(T) == -1, "GroupMenuModel::save() debe ser implementada para este tipo específico.");
    }
 
    void load(const iv::file::xml::node &node)
    {
        static_assert(sizeof(T) == -1, "GroupMenuModel::load() debe ser implementada para este tipo específico.");
    }
 
    // private:
    std::map<iv::types::groupItemId, ItemModel<T>> items;
 
private:
    struct Sections
    {
        static constexpr std::string_view items {"Items"};
        static constexpr std::string_view item {"Item"};
        static constexpr std::string_view subOptions {"SubOptions"};
        static constexpr std::string_view subOption {"SubOption"};
    };
};
 
namespace Mimic
{
struct Keys
{
    static constexpr std::string_view groupName {"Name"};
    static constexpr std::string_view groupOrder {"Order"};
    static constexpr std::string_view mimicId {"MimicId"};
    static constexpr std::string_view mimicOrder {"Order"};
};
struct Sections
{
    static constexpr std::string_view mimicGroups {"MimicGroups"};
    static constexpr std::string_view group {"Group"};
    static constexpr std::string_view mimic {"Mimic"};
};
struct DefaultValues
{
    static constexpr uint8_t order {0};
    static constexpr std::string string {};
};
}// namespace Mimic
 
template<>
void GroupMenuModel<std::weak_ptr<iv::diamar::Mimic>>::save(iv::file::xml::node &node) const;
 
template<>
void GroupMenuModel<std::weak_ptr<iv::diamar::Mimic>>::load(const iv::file::xml::node &node);
 
}// namespace iv::model
 
#endif//IV_SRC_MODEL_DIAMAR_GROUPMENUMODEL_HPP_