app/id_alloc: remove destroyed surfaces

Also, make away with those overloaded operators for generation
and lookup.

Signed-off-by: Marcus Fritzsch <marcus_fritzsch@mentor.com>

2 files changed, 28 insertions, 7 deletions

diff --git a/src/app.cpp b/src/app.cpp
index 2fd11dc..07747b9 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -382,6 +382,9 @@ void App::surface_created(uint32_t surface_id) {
 
 void App::surface_removed(uint32_t surface_id) {
    logdebug("surface_id is %u", surface_id);
+
+   this->add_task("remove surface ID",
+                  [surface_id, this] { this->id_alloc.remove_id(surface_id); });
 }
 
 result<int> App::request_surface(char const *drawing_name) {
@@ -391,10 +394,10 @@ result<int> App::request_surface(char const *drawing_name) {
       return Err<int>("Drawing name does not match any role");
    }
 
-   auto rname = this->id_alloc[drawing_name];
+   auto rname = this->id_alloc.lookup(drawing_name);
    if (!rname) {
       // name does not exist yet, allocate surface id...
-      auto id = int(this->id_alloc(drawing_name));
+      auto id = int(this->id_alloc.generate_id(drawing_name));
       this->layers.add_surface(id, lid.value());
 
       // XXX: you should fix this!
@@ -413,7 +416,7 @@ result<int> App::request_surface(char const *drawing_name) {
 }
 
 char const *App::activate_surface(char const *drawing_name) {
-   auto osid = this->id_alloc[drawing_name];
+   auto osid = this->id_alloc.lookup(drawing_name);
 
    if (osid) {
       logdebug("ativate surface with name %s and id %u", drawing_name,
diff --git a/src/app.hpp b/src/app.hpp
index c3c2060..8f30d96 100644
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -53,8 +53,8 @@ struct id_allocator {
    id_allocator &operator=(id_allocator const &);
    id_allocator &operator=(id_allocator &&) = delete;
 
-   // Allocate a new ID
-   unsigned operator()(std::string const &name) {
+   // Insert and return a new ID
+   unsigned generate_id(std::string const &name) {
       unsigned sid = this->next++;
       this->surfaces[sid] = name;
       // this->pending_surfaces.insert({sid});
@@ -64,16 +64,34 @@ struct id_allocator {
    }
 
    // Lookup by ID or by name
-   optional<unsigned> operator[](std::string const &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);
    }
 
-   optional<std::string> operator[](unsigned id) {
+   optional<std::string> lookup(unsigned id) const {
       auto i = this->surfaces.find(id);
       return i == this->surfaces.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);
+      }
+   }
+
+   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);
+      }
+   }
 };
 
 struct App {