LogViewer
A modern log viewer with AI-assisted analysis (Qt 6)
Loading...
Searching...
No Matches
IModelObservable.hpp
Go to the documentation of this file.
1
8#ifndef MVC_MODEL_OBSERVABLE_HPP
9#define MVC_MODEL_OBSERVABLE_HPP
10
11#include "IView.hpp"
12#include "Logger.hpp"
13#include <algorithm>
14#include <memory>
15#include <shared_mutex>
16#include <vector>
17
18namespace mvc {
19
53 public:
55 using ViewPtr = std::shared_ptr<IView>;
56
57 virtual ~IModelObservable() = default;
58
77 {
78 if (!view) {
79 util::Logger::Warn("Attempt to register null view");
80 return;
81 }
82
83 {
84 std::unique_lock lock(m_viewsMutex);
85 m_weakViews.push_back(std::weak_ptr<IView>(view));
87 util::Logger::Trace("View registered, total: {} active views",
88 m_weakViews.size());
89 }
90 // Call into view AFTER releasing the lock to avoid re-entrancy deadlock
91 view->OnAttachedToModel(this);
92 }
93
101 void UnregisterView(const IView* view)
102 {
103 if (!view) {
104 return;
105 }
106
107 ViewPtr found;
108 {
109 std::unique_lock lock(m_viewsMutex);
110
111 for (auto& weak : m_weakViews) {
112 if (auto v = weak.lock(); v && v.get() == view) {
113 found = v;
114 break;
115 }
116 }
117
118 m_weakViews.erase(
119 std::remove_if(m_weakViews.begin(), m_weakViews.end(),
120 [view](const auto& weak) {
121 auto shared = weak.lock();
122 return !shared || shared.get() == view;
123 }),
124 m_weakViews.end());
125
126 util::Logger::Trace("View unregistered, remaining: {} views",
127 m_weakViews.size());
128 }
129 // Call into view AFTER releasing the lock
130 if (found) {
131 found->OnDetachedFromModel();
132 }
133 }
134
139 size_t GetViewCount() const
140 {
141 std::shared_lock lock(m_viewsMutex);
142 return static_cast<size_t>(
143 std::count_if(m_weakViews.begin(), m_weakViews.end(),
144 [](const auto& w) { return !w.expired(); }));
145 }
146
147 protected:
160 {
161 // Snapshot live views under lock, then notify outside the lock.
162 // This prevents deadlock from lock upgrade (shared→unique) and
163 // re-entrancy if a view calls back into the model during notification.
164 std::vector<ViewPtr> live;
165 {
166 std::unique_lock lock(m_viewsMutex);
168 live.reserve(m_weakViews.size());
169 for (auto& weak : m_weakViews) {
170 if (auto v = weak.lock()) live.push_back(v);
171 }
172 }
173
174 for (auto& view : live) {
175 try {
176 view->OnDataUpdated();
177 } catch (const std::exception& e) {
178 util::Logger::Error("Observer error in OnDataUpdated: {}",
179 e.what());
180 }
181 }
182 }
183
190 {
191 std::vector<ViewPtr> live;
192 {
193 std::unique_lock lock(m_viewsMutex);
194 live.reserve(m_weakViews.size());
195 for (auto& weak : m_weakViews) {
196 if (auto v = weak.lock()) live.push_back(v);
197 }
198 }
199
200 for (auto& view : live) {
201 try {
202 view->OnCurrentIndexUpdated(index);
203 } catch (const std::exception& e) {
204 util::Logger::Error("Observer error in OnCurrentIndexUpdated: {}",
205 e.what());
206 }
207 }
208 }
209
218 {
219 std::unique_lock lock(m_viewsMutex);
221 }
222
223 private:
225 mutable std::shared_mutex m_viewsMutex;
226 std::vector<std::weak_ptr<IView>> m_weakViews;
227
235 {
236 auto erased = std::remove_if(
237 m_weakViews.begin(), m_weakViews.end(),
238 [](const auto& weak) { return weak.expired(); });
239
240 const size_t count = static_cast<size_t>(
241 std::distance(erased, m_weakViews.end()));
242 if (count > 0) {
243 util::Logger::Trace("Cleaned up {} expired view observers", count);
244 m_weakViews.erase(erased, m_weakViews.end());
245 }
246 }
247};
248
249} // namespace mvc
250
251#endif // MVC_MODEL_OBSERVABLE_HPP
Interface for view components in the MVC architecture.
Logging facade for application-wide logging.
Improved IModel with weak_ptr observers for automatic cleanup.
Definition IModelObservable.hpp:52
size_t GetViewCount() const
Gets count of currently active observers.
Definition IModelObservable.hpp:139
std::shared_mutex m_viewsMutex
Storage for observer weak pointers - automatically manages cleanup.
Definition IModelObservable.hpp:225
void UnregisterView(const IView *view)
Unregisters a view from observations.
Definition IModelObservable.hpp:101
void CleanupDeadObservers()
Manually triggers cleanup of dead observers.
Definition IModelObservable.hpp:217
std::vector< std::weak_ptr< IView > > m_weakViews
Definition IModelObservable.hpp:226
virtual ~IModelObservable()=default
std::shared_ptr< IView > ViewPtr
Shared pointer type for views.
Definition IModelObservable.hpp:55
void RegisterView(ViewPtr view)
Registers a view as observer with automatic cleanup.
Definition IModelObservable.hpp:76
void CleanupDeadViews()
Internal method to clean up expired weak pointers.
Definition IModelObservable.hpp:234
void NotifyCurrentIndexUpdated(int index)
Notifies all views of current item index change.
Definition IModelObservable.hpp:189
void NotifyDataChanged()
Notifies all registered views that data has changed.
Definition IModelObservable.hpp:159
Interface for view components in the MVC architecture.
Definition IView.hpp:26
static void Warn(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logger.hpp:297
static void Trace(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logger.hpp:279
static void Error(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logger.hpp:303
Definition IControler.hpp:27