6df40300-503d-431f-87b0-40d5fc812173

Committed 05 Mar 2026 07:06PM UTC coverage: 57.896% (-0.01%) from 57.909%

Build # 6df40300-503d-431f-87b0-40d5fc812173

Build Type

push

circleci

Committed by

NeonGE

Commit Message

Make core classes final, modernize lambdas and destructors

Refactored several classes to be final and updated destructors to use override for safer inheritance. Switched event signal lambdas in main.cpp to non-capturing for improved safety and efficiency. Annotated ImGuiPlatform member with GE_NO_UNIQUE_ADDRESS for potential memory optimization. Used C++20 map contains in FileTracker for cleaner code. These changes enhance code safety, clarity, and performance.

Make classes final, clean up destructors, improve safety

Refactored several classes to be final and removed unnecessary virtual destructors, marking them override where appropriate. Updated event signal lambdas in main.cpp to be non-capturing for better performance and safety. Annotated ImGuiPlatform with GE_NO_UNIQUE_ADDRESS for potential memory optimizations. Switched to C++20 map contains in geFileTracker.h when available. In geFrameAlloc.cpp, allocation functions now safely return nullptr if m_freeBlock is null, improving robustness.

Coverage Stats

0 of 8 new or added lines in 4 files covered. (0.0%)

3 existing lines in 2 files now uncovered.

5613 of 9695 relevant lines covered (57.9%)

9099.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/sdk/geCore/include/geFileTracker.h

/*****************************************************************************/
/**
 * @file    geFileWatcher.h
 * @author  Samuel Prince (samuel.prince.quezada@gmail.com)
 * @date    2025/06/26
 * @brief   File Watcher System.
 *
 * File Watcher System. This system is a subscription-based system that informs
 * the engine when a file is modified, created or deleted. It can be used to
 * automatically reload resources when they are modified.
 *
 * @bug            No known bugs.
 */
/*****************************************************************************/
#pragma once

/*****************************************************************************/
/**
 * Includes
 */
/*****************************************************************************/
#include "gePrerequisitesCore.h"

#include <geEvent.h>
#include <geModule.h>
#include <geStringID.h>
#include <geFileSystem.h>
#include <geDebug.h>

namespace geEngineSDK {

  using FILE_CHANGED_EVENT_CALLBACK = void(const PlatformString&);
  using ChangeCallback = Event<FILE_CHANGED_EVENT_CALLBACK>;

  struct TrackedFile
  {
    bool
    operator==(const TrackedFile& other) const {
      return m_systemID == other.m_systemID && m_filePath == other.m_filePath;
    }

    bool
    operator<(const TrackedFile& other) const {
      if (m_systemID < other.m_systemID) {
        return true;
      }
      if (m_systemID > other.m_systemID) {
        return false;
      }
      return m_filePath < other.m_filePath;
    }

    uint32 m_systemID = 0;          //ID of the system that is watching the file
    PlatformString m_filePath;      //Absolute path of the file being watched
    time_t m_lastModifiedTime = 0;  //Last modified time of the file
  };

  struct TrackedFileHash
  {
    std::size_t
    operator()(const TrackedFile& file) const _NOEXCEPT {
      return std::hash<uint32>()(file.m_systemID) ^
             std::hash<PlatformString>()(file.m_filePath);
    }
  };

  class GE_CORE_EXPORT FileTracker final : public Module<FileTracker>
  {
   public:
    FileTracker() = default;
    ~FileTracker() override = default;

    /**
     * @brief Start monitoring the files
     */
    void
    startWatching() {
      m_stopFlag = false;
      m_monitoringThread = Thread(&FileTracker::watchFiles, this);
    }

    /**
     * @brief Stop monitoring the files
     */
    void
    stopWatching() {
      m_stopFlag = true;
      if (m_monitoringThread.joinable()) {
        m_monitoringThread.join();
      }
    }

    /**
     * @brief Subscribe to file changes for a specific system
     * @param systemID ID of the system that is subscribing to file changes
     * @param callback Callback function to be called when a file change is detected
     */
    uint32
    subscribe(const String systemName, const ChangeCallback& callback) {
      uint32 systemID = StringID(systemName).id();

      ScopedLock<true> lock(m_dataMutex);
#if USING(GE_CPP20_OR_LATER)
      if(!m_subscribersCallbacks.contains(systemID)) {
#else
      if (m_subscribersCallbacks.find(systemID) == m_subscribersCallbacks.end()) {
#endif
        m_subscribersCallbacks[systemID] = callback;
      }

      return systemID;
    }

    /**
     * @brief Unsubscribe from file changes for a specific system
     * @param systemID ID of the system that is unsubscribing from file changes
     */
    void
    unsubscribe(const StringID systemID) {
      ScopedLock<true> lock(m_dataMutex);
      m_subscribersCallbacks.erase(systemID.id());
    }

    /**
     * @brief Add files to be watched
     * @param directory
     */
    void
    addFiles(const uint32 systemID, const Vector<Path>& newFiles);

    /**
     * @brief Add directories to be watched
     * @param directory
     */
    void
    clearFiles() {
      ScopedLock<true> lock(m_dataMutex);
      m_filesToWatch.clear();
    }

   protected:
    void
    onStartUp() override;

    void
    onShutDown() override;

   private:
    /**
     * @brief Thread function that watches the files
     */
    void
    watchFiles();

    UnorderedMap<uint32, ChangeCallback> m_subscribersCallbacks;
    UnorderedSet<TrackedFile, TrackedFileHash> m_filesToWatch;

    Thread m_monitoringThread;
    Mutex m_dataMutex;
    atomic<bool> m_stopFlag{ false };
  };

  GE_CORE_EXPORT FileTracker&
  g_fileWatcher();

  GE_LOG_CATEGORY(FileTracker, 500);
}

1	/*****************************************************************************/
2	/**
3	* @file geFileWatcher.h
4	* @author Samuel Prince (samuel.prince.quezada@gmail.com)
5	* @date 2025/06/26
6	* @brief File Watcher System.
7	*
8	* File Watcher System. This system is a subscription-based system that informs
9	* the engine when a file is modified, created or deleted. It can be used to
10	* automatically reload resources when they are modified.
11	*
12	* @bug No known bugs.
13	*/
14	/*****************************************************************************/
15	#pragma once
16
17	/*****************************************************************************/
18	/**
19	* Includes
20	*/
21	/*****************************************************************************/
22	#include "gePrerequisitesCore.h"
23
24	#include <geEvent.h>
25	#include <geModule.h>
26	#include <geStringID.h>
27	#include <geFileSystem.h>
28	#include <geDebug.h>
29
30	namespace geEngineSDK {
31
32	using FILE_CHANGED_EVENT_CALLBACK = void(const PlatformString&);
33	using ChangeCallback = Event<FILE_CHANGED_EVENT_CALLBACK>;
34
35	struct TrackedFile
36	{
37	bool
38	operator==(const TrackedFile& other) const {	×
39	return m_systemID == other.m_systemID && m_filePath == other.m_filePath;	×
40	}
41
42	bool
43	operator<(const TrackedFile& other) const {
44	if (m_systemID < other.m_systemID) {
45	return true;
46	}
47	if (m_systemID > other.m_systemID) {
48	return false;
49	}
50	return m_filePath < other.m_filePath;
51	}
52
53	uint32 m_systemID = 0; //ID of the system that is watching the file
54	PlatformString m_filePath; //Absolute path of the file being watched
55	time_t m_lastModifiedTime = 0; //Last modified time of the file
56	};
57
58	struct TrackedFileHash
59	{
60	std::size_t
61	operator()(const TrackedFile& file) const _NOEXCEPT {	×
62	return std::hash<uint32>()(file.m_systemID) ^	×
63	std::hash<PlatformString>()(file.m_filePath);	×
64	}
65	};
66
67	class GE_CORE_EXPORT FileTracker final : public Module<FileTracker>
68	{
69	public:
70	FileTracker() = default;	×
NEW 71	~FileTracker() override = default;	×
72
73	/**
74	* @brief Start monitoring the files
75	*/
76	void
77	startWatching() {
78	m_stopFlag = false;
79	m_monitoringThread = Thread(&FileTracker::watchFiles, this);
80	}
81
82	/**
83	* @brief Stop monitoring the files
84	*/
85	void
86	stopWatching() {	×
87	m_stopFlag = true;	×
88	if (m_monitoringThread.joinable()) {	×
89	m_monitoringThread.join();	×
90	}
91	}	×
92
93	/**
94	* @brief Subscribe to file changes for a specific system
95	* @param systemID ID of the system that is subscribing to file changes
96	* @param callback Callback function to be called when a file change is detected
97	*/
98	uint32
99	subscribe(const String systemName, const ChangeCallback& callback) {	×
100	uint32 systemID = StringID(systemName).id();	×
101
102	ScopedLock<true> lock(m_dataMutex);	×
103	#if USING(GE_CPP20_OR_LATER)
NEW 104	if(!m_subscribersCallbacks.contains(systemID)) {	×
105	#else
106	if (m_subscribersCallbacks.find(systemID) == m_subscribersCallbacks.end()) {
107	#endif
UNCOV 108	m_subscribersCallbacks[systemID] = callback;	×
109	}
110
111	return systemID;	×
112	}	×
113
114	/**
115	* @brief Unsubscribe from file changes for a specific system
116	* @param systemID ID of the system that is unsubscribing from file changes
117	*/
118	void
119	unsubscribe(const StringID systemID) {
120	ScopedLock<true> lock(m_dataMutex);
121	m_subscribersCallbacks.erase(systemID.id());
122	}
123
124	/**
125	* @brief Add files to be watched
126	* @param directory
127	*/
128	void
129	addFiles(const uint32 systemID, const Vector<Path>& newFiles);
130
131	/**
132	* @brief Add directories to be watched
133	* @param directory
134	*/
135	void
136	clearFiles() {	×
137	ScopedLock<true> lock(m_dataMutex);	×
138	m_filesToWatch.clear();	×
139	}	×
140
141	protected:
142	void
143	onStartUp() override;
144
145	void
146	onShutDown() override;
147
148	private:
149	/**
150	* @brief Thread function that watches the files
151	*/
152	void
153	watchFiles();
154
155	UnorderedMap<uint32, ChangeCallback> m_subscribersCallbacks;
156	UnorderedSet<TrackedFile, TrackedFileHash> m_filesToWatch;
157
158	Thread m_monitoringThread;
159	Mutex m_dataMutex;
160	atomic<bool> m_stopFlag{ false };
161	};
162
163	GE_CORE_EXPORT FileTracker&
164	g_fileWatcher();
165
166	GE_LOG_CATEGORY(FileTracker, 500);
167	}

NeonGE / geEngineSDK / 6df40300-503d-431f-87b0-40d5fc812173

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous