attempt to improve clarity/intention

Author: Klaim

libmamba/include/mamba/download/mirror.hpp

@@ -9,7 +9,6 @@
 
 #include <functional>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <string>
 #include <vector>

libmamba/src/core/output.cpp

@@ -276,11 +276,6 @@ namespace mamba
 
     using ConsoleBuffer = std::vector<std::string>;
 
-    struct ConsoleSynchedData
-    {
-        std::unique_ptr<ProgressBarManager> progress_bar_manager;
-        ConsoleBuffer buffer;
-    };
 
     class ConsoleData
     {
@@ -297,15 +292,20 @@ namespace mamba
         ConsoleData(ConsoleData&&) noexcept = delete;
         ConsoleData& operator=(ConsoleData&&) noexcept = delete;
 
+
         const Context& m_context;
 
         std::string json_hier;
         unsigned int json_index = 0;
         nlohmann::json json_log;
         bool is_json_print_cancelled = false;
 
-
-        util::synchronized_value<ConsoleSynchedData> m_synched_data;
+        struct Data
+        {
+            std::unique_ptr<ProgressBarManager> progress_bar_manager;
+            ConsoleBuffer buffer;
+        };
+        util::synchronized_value<Data> m_synched_data;
 
         TaskSynchronizer m_tasksync;
     };

libmamba/src/core/util.cpp

@@ -1065,26 +1065,7 @@ namespace mamba
 #pragma GCC diagnostic pop
 #endif
 
-        struct LockedFilesData
-        {
-            // TODO: replace by something like boost::multiindex or equivalent to avoid having to
-            // handle 2 hashmaps
-            std::unordered_map<fs::u8path, std::weak_ptr<LockFileOwner>> locked_files;  // TODO:
-                                                                                        // consider
-                                                                                        // replacing
-                                                                                        // by real
-                                                                                        // concurrent
-                                                                                        // set to
-                                                                                        // avoid
-                                                                                        // having to
-                                                                                        // lock the
-                                                                                        // whole
-                                                                                        // container
-
-            std::unordered_map<int, fs::u8path> fd_to_locked_path;  // this is a workaround the
-                                                                    // usage of file descriptors on
-                                                                    // linux instead of paths
-        };
+
 
         class LockedFilesRegistry
         {
@@ -1188,7 +1169,31 @@ namespace mamba
             std::atomic_bool m_is_file_locking_allowed{ true };
             std::atomic<std::chrono::seconds> m_default_lock_timeout{ std::chrono::seconds::zero() };
 
-            util::synchronized_value<LockedFilesData, std::recursive_mutex> m_data;
+            struct Data
+            {
+                // TODO: replace by something like boost::multiindex or equivalent to avoid having
+                // to handle 2 hashmaps
+                std::unordered_map<fs::u8path, std::weak_ptr<LockFileOwner>> locked_files;  // TODO:
+                                                                                            // consider
+                                                                                            // replacing
+                                                                                            // by
+                                                                                            // real
+                                                                                            // concurrent
+                                                                                            // set
+                                                                                            // to
+                                                                                            // avoid
+                                                                                            // having
+                                                                                            // to
+                                                                                            // lock
+                                                                                            // the
+                                                                                            // whole
+                                                                                            // container
+
+                std::unordered_map<int, fs::u8path> fd_to_locked_path;  // this is a workaround the
+                                                                        // usage of file descriptors
+                                                                        // on linux instead of paths
+            };
+            util::synchronized_value<Data, std::recursive_mutex> m_data;
         };
 
         static LockedFilesRegistry files_locked_by_this_process;