App: cleanup name/id mapping and its reverse

[staging/windowmanager.git] / src / app.hpp

diff --git a/src/app.hpp b/src/app.hpp
index 6921865..370c65d 100644 (file)
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -48,9 +48,9 @@ struct id_allocator {
    unsigned next = 1;
 
    // Surfaces that where requested but not yet created
-   std::unordered_map<unsigned, std::string> surfaces;
+   std::unordered_map<unsigned, std::string> id2name;
    // std::unordered_set<unsigned> pending_surfaces;
-   std::unordered_map<std::string, unsigned> names;
+   std::unordered_map<std::string, unsigned> name2id;
 
    id_allocator(id_allocator const &) = delete;
    id_allocator(id_allocator &&) = delete;
@@ -60,40 +60,40 @@ struct id_allocator {
    // Insert and return a new ID
    unsigned generate_id(std::string const &name) {
       unsigned sid = this->next++;
-      this->surfaces[sid] = name;
+      this->id2name[sid] = name;
       // this->pending_surfaces.insert({sid});
-      this->names[name] = sid;
+      this->name2id[name] = sid;
       logdebug("allocated new id %u with name %s", sid, name.c_str());
       return sid;
    }
 
    // Lookup by ID or by name
    optional<unsigned> lookup(std::string const &name) const {
-      auto i = this->names.find(name);
-      return i == this->names.end() ? nullopt : optional<unsigned>(i->second);
+      auto i = this->name2id.find(name);
+      return i == this->name2id.end() ? nullopt : optional<unsigned>(i->second);
    }
 
    optional<std::string> lookup(unsigned id) const {
-      auto i = this->surfaces.find(id);
-      return i == this->surfaces.end() ? nullopt
+      auto i = this->id2name.find(id);
+      return i == this->id2name.end() ? nullopt
                                        : optional<std::string>(i->second);
    }
 
    // Remove a surface id and name
    // I don't think I will need this, do I?
    void remove_id(std::string const &name) {
-      auto i = this->names.find(name);
-      if (i != this->names.end()) {
-         this->surfaces.erase(i->second);
-         this->names.erase(i);
+      auto i = this->name2id.find(name);
+      if (i != this->name2id.end()) {
+         this->id2name.erase(i->second);
+         this->name2id.erase(i);
       }
    }
 
    void remove_id(unsigned id) {
-      auto i = this->surfaces.find(id);
-      if (i != this->surfaces.end()) {
-         this->names.erase(i->second);
-         this->surfaces.erase(i);
+      auto i = this->id2name.find(id);
+      if (i != this->id2name.end()) {
+         this->name2id.erase(i->second);
+         this->id2name.erase(i);
       }
    }
 };
@@ -113,12 +113,13 @@ struct App {
    layouts_type layouts;
    layer_map layers;
 
-   typedef std::pair<char const *, std::function<void()>> name_task_pair;
-
-   typedef std::map<std::string, int> drawing_name_map;
-   drawing_name_map name_mapping;
-
    struct id_allocator id_alloc;
+   optional<unsigned> lookup_id(char const *name) {
+      return this->id_alloc.lookup(std::string(name));
+   }
+   optional<std::string> lookup_name(unsigned id) {
+      return this->id_alloc.lookup(id);
+   }
 
    std::deque<unsigned> last_active;
 
@@ -136,8 +137,6 @@ struct App {
    int dispatch_events();
 
    void surface_set_layout(uint32_t surface_id);
-   char const *activate_surface(uint32_t surface_id);
-   char const *deactivate_surface(uint32_t surface_id);
 
    // Allocate a surface ID for this role
    result<int> request_surface(char const *drawing_name);