liblava/liblava/util/layer.hpp at flow · mcpplibs/liblava · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
/**
 * @file         liblava/util/layer.hpp
 * @brief        Layering
 * @authors      Lava Block OÜ and contributors
 * @copyright    Copyright (c) 2018-present, MIT License
 */

#pragma once

#include "liblava/core/id.hpp"
#include "liblava/core/misc.hpp"

namespace lava {

/**
 * @brief Layer
 */
struct layer : entity {
    /// Shared pointer to layer
    using s_ptr = std::shared_ptr<layer>;

    /// Map of layers
    using map = std::map<id, s_ptr>;

    /// List of layers
    using list = std::vector<s_ptr>;

    /// Layer function
    using func = std::function<void()>;

    /**
     * @brief Make a new layer
     * @param name      Name of layer
     * @return s_ptr    Shared pointer to layer
     */
    static s_ptr make(string_ref name) {
        return std::make_shared<layer>(name);
    }

    /**
     * @brief Construct a new layer
     * @param name    Name of layer
     */
    layer(string_ref name)
    : name(name) {}

    /// Called by layering
    func on_func;

    /// Active state
    bool active = true;

    /// Name of layer
    string name;
};

/**
 * @brief Layer list
 */
struct layer_list {
    /// Pointer to layer list
    using ptr = layer_list*;

    /**
     * @brief Add a new layer
     * @param name      Name of layer
     * @param func      Layer function
     * @param active    Layer active state
     * @return id       Id of added layer
     */
    id add(string_ref name,
           layer::func func,
           bool active = true) {
        auto layer = layer::make(name);

        layer->on_func = func;
        layer->active = active;

        m_layers.push_back(layer);

        return layer->get_id();
    }

    /**
     * @brief Add a layer
     * @param layer    Layer to add
     */
    void add(layer::s_ptr layer) {
        m_layers.push_back(layer);
    }

    /**
     * @brief Add a new inactive layer
     * @param name    Name of layer
     * @param func    Layer function
     * @return id     Id of added layer
     */
    id add_inactive(string_ref name,
                    layer::func func) {
        return add(name, func, false);
    }

    /**
     * @brief Get layer in list by id
     * @param layer_id       Id of layer
     * @return layer::ptr    Shared pointer to layer
     */
    layer::s_ptr get(id::ref layer_id) {
        for (auto const& layer : m_layers)
            if (layer->get_id() == layer_id)
                return layer;

        return nullptr;
    }

    /**
     * @brief Remove layer from list
     * @param layer_id    Id of layer to remove
     * @return Remove was successful or failed
     */
    bool remove(id::ref layer_id) {
        for (auto const& layer : m_layers) {
            if (layer->get_id() == layer_id) {
                lava::remove(m_layers, layer);
                return true;
            }
        }

        return false;
    }

    /**
     * @brief Get all layers
     * @return layer::list const&    List of layers
     */
    layer::list const& get_all() const {
        return m_layers;
    }

    /**
     * @brief Clear layer list
     */
    void clear() {
        m_layers.clear();
    }

private:
    /// List of layers
    layer::list m_layers;
};

} // namespace lava