Remove indexed maps that are not used along the code

.github/workflows/test.meta

@@ -16,7 +16,8 @@
                 "-DBUILD_TESTS=ON",
                 "-DCMAKE_BUILD_TYPE=Debug",
                 "-DCOMPILE_EXAMPLES=ON",
-                "-DCMAKE_CXX_FLAGS='-Werror'",
+                "-DCMAKE_C_FLAGS='--coverage'",
+                "-DCMAKE_CXX_FLAGS='-Werror --coverage'"
             ]
         }
     }

.github/workflows/test.yml

@@ -116,8 +116,7 @@ jobs:
           cat src/Fast-DDS-statistics-backend/.github/workflows/test.meta
           colcon build \
             --event-handlers=console_direct+ \
-            --metas src/Fast-DDS-statistics-backend/.github/workflows/test.meta \
-            --mixin coverage-gcc
+            --metas src/Fast-DDS-statistics-backend/.github/workflows/test.meta
 
       - name: Run tests
         run: |

src/cpp/database/database.cpp

@@ -1242,12 +1242,6 @@ void Database::link_participant_with_process_nts(
     auto participant = participant_it->second;
     process_it->second->participants[participant_it->first] = participant;
 
-    /* Add entry to domains_by_process_ */
-    domains_by_process_[process_it->first][domain_id] = participant_it->second->domain;
-
-    /* Add entry to processes_by_domain_ */
-    processes_by_domain_[domain_id][process_it->first] = process_it->second;
-
     // If the participant is active, the process must be active
     if (participant->active)
     {
@@ -1539,25 +1533,10 @@ void Database::erase(
                         EntityKind::PROCESS, domain_id);
             }
         }
-        // Erase locators_by_participant map element
-        locators_by_participant_.erase(participant.second->id);
-        // Erase participants_by_locator_ participant reference
-        for (auto& locator : participants_by_locator_)
-        {
-            locator.second.erase(participant.second->id);
-        }
     }
     // Erase participants map element
     participants_.erase(domain_id);
 
-    // Erase processes_by_domain_ map element
-    processes_by_domain_.erase(domain_id);
-    // Erase domains_by_process_ domain reference
-    for (auto& process : domains_by_process_)
-    {
-        process.second.erase(domain_id);
-    }
-
     // Erase domain map element
     domains_.erase(domain_id);
 }

src/cpp/database/database.hpp

@@ -118,8 +118,6 @@ class Database
      * This operation entails:
      *     1. Adding reference to process to the participant.
      *     2. Adding the participant to the process' list of participants.
-     *     3. Adding entry to domains_by_process_.
-     *     4. Adding entry to processes_by_domain_.
      *
      * @param participant_id The EntityId of the participant.
      * @param process_id The EntityId of the process.
@@ -584,11 +582,6 @@ class Database
                 throw BadParameter("Locator does not exist in the database");
             }
 
-            // Even if it is not new, it may be new to the participant
-            // Add reader's locators to locators_by_participant_
-            locators_by_participant_[endpoint->participant->id][locator_it.first] = locator_it.second;
-            // Add reader's participant to participants_by_locator_
-            participants_by_locator_[locator_it.first][endpoint->participant->id] = endpoint->participant;
             // Add endpoint to locator's collection
             insert_ddsendpoint_to_locator(endpoint, locator_it.second);
         }
@@ -740,8 +733,6 @@ class Database
      * This operation entails:
      *     1. Referencing the process from the participant.
      *     2. Adding the participant to the process' list of participants.
-     *     3. Adding entry to domains_by_process_.
-     *     4. Adding entry to processes_by_domain_.
      *
      * @param participant_id The EntityId of the participant.
      * @param process_id The EntityId of the process.
@@ -844,19 +835,6 @@ class Database
      */
     std::map<EntityId, std::map<EntityId, std::shared_ptr<Topic>>> topics_;
 
-    /* Collections with duplicated information used to speed up searches */
-    //! Domains sorted by process EntityId
-    std::map<EntityId, std::map<EntityId, std::shared_ptr<Domain>>> domains_by_process_;
-
-    //! Processes sorted by domain EntityId
-    std::map<EntityId, std::map<EntityId, std::shared_ptr<Process>>> processes_by_domain_;
-
-    //! DomainParticipants sorted by locator EntityId
-    std::map<EntityId, std::map<EntityId, std::shared_ptr<DomainParticipant>>> participants_by_locator_;
-
-    //! Locators sorted by participant EntityId
-    std::map<EntityId, std::map<EntityId, std::shared_ptr<Locator>>> locators_by_participant_;
-
     /**
      * The ID that will be assigned to the next entity.
      * Used to guarantee a unique EntityId within the database instance

test/unittest/Database/DatabaseEraseTests.cpp

@@ -54,12 +54,17 @@ void check_erased_database(
             EXPECT_EQ(locator.second->data_writers.find(writer->id), locator.second->data_writers.end());
         }
     }
+
     // Any reference to the erased domain has been deleted
-    for (auto process : db.domains_by_process())
+    auto domains_by_process = db.domains_by_process();
+    for (auto process : domains_by_process)
     {
         EXPECT_EQ(process.second.find(domain_id), process.second.end());
     }
-    EXPECT_EQ(db.processes_by_domain().find(domain_id), db.processes_by_domain().end());
+
+    auto processes_by_domain = db.processes_by_domain();
+    EXPECT_EQ(processes_by_domain.find(domain_id), processes_by_domain.end());
+
     // Any reference to the erased participant has been deleted
     for (auto participant : participants)
     {
@@ -72,7 +77,9 @@ void check_erased_database(
         {
             EXPECT_EQ(locator.second.find(participant_id), locator.second.end());
         }
-        EXPECT_EQ(db.locators_by_participant().find(participant_id), db.locators_by_participant().end());
+
+        auto locators_by_participant = db.locators_by_participant();
+        EXPECT_EQ(locators_by_participant.find(participant_id), locators_by_participant.end());
     }
 }
 

test/unittest/Database/DatabaseLoadInsertTests.cpp

@@ -456,12 +456,14 @@ TEST_F(database_load_insert_tests, load_insert)
     }
 
     // domains_by_process
-    for (auto domainIt = db.domains_by_process().cbegin(); domainIt != db.domains_by_process().cend(); ++domainIt)
-    {
-        for (auto insertedIt = db.domains_by_process().at(domainIt->first).cbegin(),
-                loadedIt = db_loaded.domains_by_process().at(domainIt->first).cbegin();
-                insertedIt != db.domains_by_process().at(domainIt->first).cend() &&
-                loadedIt != db_loaded.domains_by_process().at(domainIt->first).cend();
+    auto domain_by_process = db.domains_by_process();
+    auto loaded_domain_by_process = db_loaded.domains_by_process();
+    for (auto domainIt = domain_by_process.cbegin(); domainIt != domain_by_process.cend(); ++domainIt)
+    {
+        for (auto insertedIt = domain_by_process.at(domainIt->first).cbegin(),
+                loadedIt = loaded_domain_by_process.at(domainIt->first).cbegin();
+                insertedIt != domain_by_process.at(domainIt->first).cend() &&
+                loadedIt != loaded_domain_by_process.at(domainIt->first).cend();
                 insertedIt++, loadedIt++)
         {
             std::shared_ptr<Domain> insertedEntity = insertedIt->second;
@@ -472,12 +474,14 @@ TEST_F(database_load_insert_tests, load_insert)
     }
 
     // processes_by_domain_
-    for (auto domainIt = db.processes_by_domain().cbegin(); domainIt != db.processes_by_domain().cend(); ++domainIt)
-    {
-        for (auto insertedIt = db.processes_by_domain().at(domainIt->first).cbegin(),
-                loadedIt = db_loaded.processes_by_domain().at(domainIt->first).cbegin();
-                insertedIt != db.processes_by_domain().at(domainIt->first).cend() &&
-                loadedIt != db_loaded.processes_by_domain().at(domainIt->first).cend();
+    auto processes_by_domain = db.processes_by_domain();
+    auto loaded_processes_by_domain = db_loaded.processes_by_domain();
+    for (auto domainIt = processes_by_domain.cbegin(); domainIt != processes_by_domain.cend(); ++domainIt)
+    {
+        for (auto insertedIt = processes_by_domain.at(domainIt->first).cbegin(),
+                loadedIt = loaded_processes_by_domain.at(domainIt->first).cbegin();
+                insertedIt != processes_by_domain.at(domainIt->first).cend() &&
+                loadedIt != loaded_processes_by_domain.at(domainIt->first).cend();
                 insertedIt++, loadedIt++)
         {
             std::shared_ptr<Process> insertedEntity = insertedIt->second;
@@ -488,13 +492,15 @@ TEST_F(database_load_insert_tests, load_insert)
     }
 
     // participants_by_locator
-    for (auto domainIt = db.participants_by_locator().cbegin(); domainIt != db.participants_by_locator().cend();
+    auto participants_by_locator = db.participants_by_locator();
+    auto loaded_participants_by_locator = db_loaded.participants_by_locator();
+    for (auto domainIt = participants_by_locator.cbegin(); domainIt != participants_by_locator.cend();
             ++domainIt)
     {
-        for (auto insertedIt = db.participants_by_locator().at(domainIt->first).cbegin(),
-                loadedIt = db_loaded.participants_by_locator().at(domainIt->first).cbegin();
-                insertedIt != db.participants_by_locator().at(domainIt->first).cend() &&
-                loadedIt != db_loaded.participants_by_locator().at(domainIt->first).cend();
+        for (auto insertedIt = participants_by_locator.at(domainIt->first).cbegin(),
+                loadedIt = loaded_participants_by_locator.at(domainIt->first).cbegin();
+                insertedIt != participants_by_locator.at(domainIt->first).cend() &&
+                loadedIt != loaded_participants_by_locator.at(domainIt->first).cend();
                 insertedIt++, loadedIt++)
         {
             std::shared_ptr<DomainParticipant> insertedEntity = insertedIt->second;
@@ -505,13 +511,15 @@ TEST_F(database_load_insert_tests, load_insert)
     }
 
     // locators_by_participant
-    for (auto domainIt = db.locators_by_participant().cbegin(); domainIt != db.locators_by_participant().cend();
+    auto locators_by_participant = db.locators_by_participant();
+    auto loaded_locators_by_participant = db_loaded.locators_by_participant();
+    for (auto domainIt = locators_by_participant.cbegin(); domainIt != locators_by_participant.cend();
             ++domainIt)
     {
-        for (auto insertedIt = db.locators_by_participant().at(domainIt->first).cbegin(),
-                loadedIt = db_loaded.locators_by_participant().at(domainIt->first).cbegin();
-                insertedIt != db.locators_by_participant().at(domainIt->first).cend() &&
-                loadedIt != db_loaded.locators_by_participant().at(domainIt->first).cend();
+        for (auto insertedIt = locators_by_participant.at(domainIt->first).cbegin(),
+                loadedIt = loaded_locators_by_participant.at(domainIt->first).cbegin();
+                insertedIt != locators_by_participant.at(domainIt->first).cend() &&
+                loadedIt != loaded_locators_by_participant.at(domainIt->first).cend();
                 insertedIt++, loadedIt++)
         {
             std::shared_ptr<Locator> insertedEntity = insertedIt->second;

test/unittest/TestUtils/DatabaseUtils.hpp

@@ -521,24 +521,128 @@ class DataBaseTest : public Database
         return locators_;
     }
 
-    const std::map<EntityId, std::map<EntityId, std::shared_ptr<Locator>>>& locators_by_participant() const
+    const std::map<EntityId, std::map<EntityId, std::shared_ptr<Locator>>> locators_by_participant() const
     {
-        return locators_by_participant_;
+        std::map<EntityId, std::map<EntityId, std::shared_ptr<Locator>>> result;
+
+        // For every domain
+        for (const auto& it_domain : participants_)
+        {
+            // For every participant
+            for (const auto& it_participant : it_domain.second)
+            {
+                // Add new map for this entity
+                result[it_participant.first] = std::map<EntityId, std::shared_ptr<Locator>>();
+                auto& internal_map = result[it_participant.first];
+
+                // For every DataWriter
+                for (const auto& it_endpoint : it_participant.second->data_writers)
+                {
+                    // For every Locator
+                    for (const auto& it_locator : it_endpoint.second->locators)
+                    {
+                        internal_map[it_locator.first] = it_locator.second;
+                    }
+                }
+
+                // For every DataReader
+                for (const auto& it_endpoint : it_participant.second->data_readers)
+                {
+                    // For every Locator
+                    for (const auto& it_locator : it_endpoint.second->locators)
+                    {
+                        internal_map[it_locator.first] = it_locator.second;
+                    }
+                }
+
+                // For every metatraffic locator
+                if (it_participant.second->meta_traffic_endpoint)
+                {
+                    for (const auto& it_locator : it_participant.second->meta_traffic_endpoint->locators)
+                    {
+                        internal_map[it_locator.first] = it_locator.second;
+                    }
+                }
+            }
+        }
+
+        return result;
     }
 
-    const std::map<EntityId, std::map<EntityId, std::shared_ptr<DomainParticipant>>>& participants_by_locator() const
+    const std::map<EntityId, std::map<EntityId, std::shared_ptr<DomainParticipant>>> participants_by_locator() const
     {
-        return participants_by_locator_;
+        std::map<EntityId, std::map<EntityId, std::shared_ptr<DomainParticipant>>> result;
+
+        // For every locator
+        for (const auto& it_locator : locators_)
+        {
+            // Add new map for this entity
+            result[it_locator.first] = std::map<EntityId, std::shared_ptr<DomainParticipant>>();
+            auto& internal_map = result[it_locator.first];
+
+            // For every DataWriter
+            for (const auto& it_endpoint : it_locator.second->data_writers)
+            {
+                // Add Participant
+                internal_map[it_endpoint.second->participant->id] = it_endpoint.second->participant;
+            }
+
+            // For every DataReader
+            for (const auto& it_endpoint : it_locator.second->data_readers)
+            {
+                // Add Participant
+                internal_map[it_endpoint.second->participant->id] = it_endpoint.second->participant;
+            }
+        }
+
+        return result;
     }
 
-    const std::map<EntityId, std::map<EntityId, std::shared_ptr<Domain>>>& domains_by_process() const
+    const std::map<EntityId, std::map<EntityId, std::shared_ptr<Domain>>> domains_by_process() const
     {
-        return domains_by_process_;
+        std::map<EntityId, std::map<EntityId, std::shared_ptr<Domain>>> result;
+
+        // For every process
+        for (const auto& it_process : processes_)
+        {
+            // Add new map for this entity
+            result[it_process.first] = std::map<EntityId, std::shared_ptr<Domain>>();
+            auto& internal_map = result[it_process.first];
+
+            // For every Participant
+            for (const auto& it_participant : it_process.second->participants)
+            {
+                // Add domain
+                internal_map[it_participant.second->domain->id] = it_participant.second->domain;
+            }
+        }
+
+        return result;
     }
 
-    const std::map<EntityId, std::map<EntityId, std::shared_ptr<Process>>>& processes_by_domain() const
+    const std::map<EntityId, std::map<EntityId, std::shared_ptr<Process>>> processes_by_domain() const
     {
-        return processes_by_domain_;
+        std::map<EntityId, std::map<EntityId, std::shared_ptr<Process>>> result;
+
+        // For every domain
+        for (const auto& it_domain : domains_)
+        {
+            // Add new map for this entity
+            result[it_domain.first] = std::map<EntityId, std::shared_ptr<Process>>();
+            auto& internal_map = result[it_domain.first];
+
+            // For every Participant
+            for (const auto& it_participant : it_domain.second->participants)
+            {
+                // Add process if exist
+                if (it_participant.second->process)
+                {
+                    internal_map[it_participant.second->process->id] = it_participant.second->process;
+                }
+            }
+        }
+
+        return result;
     }
 
     template<typename T>