| //+------------------------------------------------------------------+
|
| //| CResourceManager.mqh - Automated Resource Lifecycle Management |
|
| //| Handles: indicator handles, file handles, memory allocations |
|
| //+------------------------------------------------------------------+
|
| #ifndef CRESOURCE_MANAGER_MQH
|
| #define CRESOURCE_MANAGER_MQH
|
|
|
| //+------------------------------------------------------------------+
|
| //| Resource Types |
|
| //+------------------------------------------------------------------+
|
| enum ENUM_RESOURCE_TYPE
|
| {
|
| RES_INDICATOR_HANDLE = 0, // iMA, iRSI, etc. handles
|
| RES_FILE_HANDLE = 1, // FileOpen handles
|
| RES_DYNAMIC_ARRAY = 2, // Dynamically allocated arrays
|
| RES_OBJECT_PTR = 3, // CObject pointers
|
| RES_NETWORK_HANDLE = 4 // Socket/HTTP handles
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Resource Entry Structure |
|
| //+------------------------------------------------------------------+
|
| struct SResourceEntry
|
| {
|
| long resource_id; // Handle or pointer value
|
| ENUM_RESOURCE_TYPE type; // Resource type
|
| string owner; // Component that allocated it
|
| string description; // Human-readable description
|
| datetime alloc_time; // When it was allocated
|
| int alloc_line; // Line number in source
|
| string alloc_file; // Source file
|
|
|
| void Set(long id, ENUM_RESOURCE_TYPE t, const string own,
|
| const string desc, const string file, int line)
|
| {
|
| resource_id = id;
|
| type = t;
|
| owner = own;
|
| description = desc;
|
| alloc_time = TimeCurrent();
|
| alloc_line = line;
|
| alloc_file = file;
|
| }
|
|
|
| bool IsValid() { return resource_id != 0; }
|
|
|
| void Clear()
|
| {
|
| resource_id = 0;
|
| type = RES_INDICATOR_HANDLE;
|
| owner = "";
|
| description = "";
|
| alloc_time = 0;
|
| alloc_line = 0;
|
| alloc_file = "";
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Resource Manager Class |
|
| //+------------------------------------------------------------------+
|
| class CResourceManager
|
| {
|
| private:
|
| SResourceEntry m_resources[];
|
| int m_capacity;
|
| int m_count;
|
|
|
| // Statistics
|
| int m_total_allocated[5];
|
| int m_total_released[5];
|
| int m_leak_detected[5];
|
|
|
| public:
|
| CResourceManager()
|
| {
|
| m_capacity = 256;
|
| m_count = 0;
|
| ArrayResize(m_resources, m_capacity);
|
|
|
| for(int i = 0; i < 5; i++)
|
| {
|
| m_total_allocated[i] = 0;
|
| m_total_released[i] = 0;
|
| m_leak_detected[i] = 0;
|
| }
|
| }
|
|
|
| ~CResourceManager()
|
| {
|
| CleanupAllResources();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Track indicator handle |
|
| //+------------------------------------------------------------------+
|
| void TrackIndicator(int handle, const string owner, const string description,
|
| const string file, int line)
|
| {
|
| if(handle == INVALID_HANDLE) return;
|
|
|
| int idx = FindFreeSlot();
|
| if(idx >= 0)
|
| {
|
| m_resources[idx].Set(handle, RES_INDICATOR_HANDLE, owner,
|
| description, file, line);
|
| m_total_allocated[RES_INDICATOR_HANDLE]++;
|
| m_count++;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Track file handle |
|
| //+------------------------------------------------------------------+
|
| void TrackFile(int handle, const string owner, const string description,
|
| const string file, int line)
|
| {
|
| if(handle == INVALID_HANDLE) return;
|
|
|
| int idx = FindFreeSlot();
|
| if(idx >= 0)
|
| {
|
| m_resources[idx].Set(handle, RES_FILE_HANDLE, owner,
|
| description, file, line);
|
| m_total_allocated[RES_FILE_HANDLE]++;
|
| m_count++;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Release indicator handle |
|
| //+------------------------------------------------------------------+
|
| bool ReleaseIndicator(int handle, const string owner)
|
| {
|
| if(handle == INVALID_HANDLE) return true;
|
|
|
| int idx = FindResource(handle, RES_INDICATOR_HANDLE, owner);
|
| if(idx >= 0)
|
| {
|
| // Actually release the indicator
|
| bool released = IndicatorRelease((int)m_resources[idx].resource_id);
|
|
|
| m_resources[idx].Clear();
|
| m_total_released[RES_INDICATOR_HANDLE]++;
|
| m_count--;
|
| return released;
|
| }
|
|
|
| // Not tracked - try to release anyway
|
| return IndicatorRelease(handle);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Release file handle |
|
| //+------------------------------------------------------------------+
|
| bool ReleaseFile(int handle, const string owner)
|
| {
|
| if(handle == INVALID_HANDLE) return true;
|
|
|
| int idx = FindResource(handle, RES_FILE_HANDLE, owner);
|
| if(idx >= 0)
|
| {
|
| // Actually close the file
|
| FileClose((int)m_resources[idx].resource_id);
|
|
|
| m_resources[idx].Clear();
|
| m_total_released[RES_FILE_HANDLE]++;
|
| m_count--;
|
| return true;
|
| }
|
|
|
| // Not tracked - try to close anyway
|
| FileClose(handle);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Release all resources for an owner |
|
| //+------------------------------------------------------------------+
|
| int ReleaseAllForOwner(const string owner)
|
| {
|
| int released = 0;
|
| for(int i = 0; i < m_capacity; i++)
|
| {
|
| if(m_resources[i].IsValid() && m_resources[i].owner == owner)
|
| {
|
| switch(m_resources[i].type)
|
| {
|
| case RES_INDICATOR_HANDLE:
|
| IndicatorRelease((int)m_resources[i].resource_id);
|
| break;
|
| case RES_FILE_HANDLE:
|
| FileClose((int)m_resources[i].resource_id);
|
| break;
|
| }
|
|
|
| m_total_released[m_resources[i].type]++;
|
| m_resources[i].Clear();
|
| released++;
|
| m_count--;
|
| }
|
| }
|
| return released;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Cleanup all resources (emergency cleanup) |
|
| //+------------------------------------------------------------------+
|
| void CleanupAllResources()
|
| {
|
| for(int i = 0; i < m_capacity; i++)
|
| {
|
| if(m_resources[i].IsValid())
|
| {
|
| switch(m_resources[i].type)
|
| {
|
| case RES_INDICATOR_HANDLE:
|
| IndicatorRelease((int)m_resources[i].resource_id);
|
| m_total_released[RES_INDICATOR_HANDLE]++;
|
| break;
|
| case RES_FILE_HANDLE:
|
| FileClose((int)m_resources[i].resource_id);
|
| m_total_released[RES_FILE_HANDLE]++;
|
| break;
|
| }
|
|
|
| m_resources[i].Clear();
|
| m_count--;
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get leak report |
|
| //+------------------------------------------------------------------+
|
| string GetLeakReport()
|
| {
|
| string report = "=== Resource Leak Report ===\n";
|
|
|
| // Calculate leaks per type
|
| for(int type = 0; type < 5; type++)
|
| {
|
| int leaked = m_total_allocated[type] - m_total_released[type];
|
| if(leaked > 0)
|
| {
|
| m_leak_detected[type] = leaked;
|
| report += StringFormat(" %s: %d leaks detected\n",
|
| TypeToString(type), leaked);
|
| }
|
| }
|
|
|
| // Show active resources
|
| if(m_count > 0)
|
| {
|
| report += StringFormat("\nActive Resources (%d total):\n", m_count);
|
| for(int i = 0; i < m_capacity; i++)
|
| {
|
| if(m_resources[i].IsValid())
|
| {
|
| report += StringFormat(" [%s] %s: %s (owner: %s, file: %s:%d)\n",
|
| TypeToString(m_resources[i].type),
|
| m_resources[i].resource_id,
|
| m_resources[i].description,
|
| m_resources[i].owner,
|
| m_resources[i].alloc_file,
|
| m_resources[i].alloc_line);
|
| }
|
| }
|
| }
|
|
|
| return report;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Get statistics |
|
| //+------------------------------------------------------------------+
|
| string GetStatistics()
|
| {
|
| string stats = "=== Resource Statistics ===\n";
|
|
|
| for(int type = 0; type < 5; type++)
|
| {
|
| if(m_total_allocated[type] > 0)
|
| {
|
| int leaked = m_total_allocated[type] - m_total_released[type];
|
| stats += StringFormat("%s: Alloc=%d, Rel=%d, Leaked=%d\n",
|
| TypeToString(type),
|
| m_total_allocated[type],
|
| m_total_released[type],
|
| leaked);
|
| }
|
| }
|
|
|
| stats += StringFormat("\nCurrent Active: %d\n", m_count);
|
| return stats;
|
| }
|
|
|
| private:
|
| int FindFreeSlot()
|
| {
|
| for(int i = 0; i < m_capacity; i++)
|
| {
|
| if(!m_resources[i].IsValid())
|
| return i;
|
| }
|
|
|
| // No free slots - expand array
|
| int old_capacity = m_capacity;
|
| m_capacity += 64;
|
| ArrayResize(m_resources, m_capacity);
|
|
|
| return old_capacity; // Return first new slot
|
| }
|
|
|
| int FindResource(long id, ENUM_RESOURCE_TYPE type, const string owner)
|
| {
|
| for(int i = 0; i < m_capacity; i++)
|
| {
|
| if(m_resources[i].IsValid() &&
|
| m_resources[i].resource_id == id &&
|
| m_resources[i].type == type &&
|
| (owner == "" || m_resources[i].owner == owner))
|
| {
|
| return i;
|
| }
|
| }
|
| return -1;
|
| }
|
|
|
| static string TypeToString(int type)
|
| {
|
| switch(type)
|
| {
|
| case RES_INDICATOR_HANDLE: return "INDICATOR";
|
| case RES_FILE_HANDLE: return "FILE";
|
| case RES_DYNAMIC_ARRAY: return "ARRAY";
|
| case RES_OBJECT_PTR: return "OBJECT";
|
| case RES_NETWORK_HANDLE: return "NETWORK";
|
| }
|
| return "UNKNOWN";
|
| }
|
| };
|
|
|
| // Global resource manager
|
| CResourceManager* g_resource_manager = NULL;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize resource management |
|
| //+------------------------------------------------------------------+
|
| bool InitializeResourceManager()
|
| {
|
| if(g_resource_manager != NULL)
|
| delete g_resource_manager;
|
|
|
| g_resource_manager = new CResourceManager();
|
| Print("[ResourceManager] Initialized");
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Shutdown resource management |
|
| //+------------------------------------------------------------------+
|
| void ShutdownResourceManager()
|
| {
|
| if(g_resource_manager != NULL)
|
| {
|
| Print(g_resource_manager.GetStatistics());
|
| Print(g_resource_manager.GetLeakReport());
|
|
|
| // Cleanup any remaining resources
|
| g_resource_manager.CleanupAllResources();
|
|
|
| delete g_resource_manager;
|
| g_resource_manager = NULL;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Convenience macros for resource tracking |
|
| //+------------------------------------------------------------------+
|
| #define TRACK_INDICATOR(handle, desc) \
|
| do { if(g_resource_manager != NULL && handle != INVALID_HANDLE) \
|
| g_resource_manager.TrackIndicator(handle, __FILE__, desc, __FILE__, __LINE__); } while(0)
|
|
|
| #define RELEASE_INDICATOR(handle) \
|
| do { if(g_resource_manager != NULL) \
|
| g_resource_manager.ReleaseIndicator(handle, __FILE__); \
|
| else if(handle != INVALID_HANDLE) IndicatorRelease(handle); } while(0)
|
|
|
| #define TRACK_FILE(handle, desc) \
|
| do { if(g_resource_manager != NULL && handle != INVALID_HANDLE) \
|
| g_resource_manager.TrackFile(handle, __FILE__, desc, __FILE__, __LINE__); } while(0)
|
|
|
| #define RELEASE_FILE(handle) \
|
| do { if(g_resource_manager != NULL) \
|
| g_resource_manager.ReleaseFile(handle, __FILE__); \
|
| else if(handle != INVALID_HANDLE) FileClose(handle); } while(0)
|
|
|
| #define RELEASE_ALL_FOR_OWNER(owner) \
|
| do { if(g_resource_manager != NULL) \
|
| g_resource_manager.ReleaseAllForOwner(owner); } while(0)
|
|
|
| #endif // CRESOURCE_MANAGER_MQH
|
