| //+------------------------------------------------------------------+
|
| //| EACore.mqh |
|
| //| Copyright 2025, Your Company Name |
|
| //| https://www.yoursite.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, Your Company Name"
|
| #property link "https://www.yoursite.com"
|
| #property version "1.00"
|
| #property strict
|
|
|
| #include "EAEvents.mqh"
|
| #include "EAState.mqh"
|
| #include "EALogger.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Core EA Class |
|
| //+------------------------------------------------------------------+
|
| class CEACore
|
| {
|
| private:
|
| CEAEvents* m_events; // Event manager
|
| CEAState* m_state; // State manager
|
| CEALogger* m_logger; // Logger instance
|
|
|
| // Core configuration
|
| string m_symbol; // Trading symbol
|
| ENUM_TIMEFRAMES m_timeframe; // Chart timeframe
|
|
|
| // Core flags
|
| bool m_isInitialized;
|
| bool m_isBacktest;
|
|
|
| public:
|
| CEACore();
|
| ~CEACore();
|
|
|
| // Core methods
|
| bool Initialize(string symbol, ENUM_TIMEFRAMES timeframe, bool isBacktest = false);
|
| void Deinitialize();
|
|
|
| // Event processing
|
| void OnTick();
|
| void OnTimer();
|
| void OnTrade();
|
|
|
| // State management
|
| bool IsInitialized() const { return m_isInitialized; }
|
|
|
| private:
|
| // Internal methods
|
| bool InitializeComponents();
|
| void CleanupComponents();
|
|
|
| // Event handlers
|
| void HandleTick();
|
| void HandleTimer();
|
| void HandleTrade();
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CEACore::CEACore() : m_events(NULL), m_state(NULL), m_logger(NULL),
|
| m_isInitialized(false), m_isBacktest(false), m_symbol(""), m_timeframe(PERIOD_CURRENT)
|
| {
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CEACore::~CEACore()
|
| {
|
| Deinitialize();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize core EA components |
|
| //+------------------------------------------------------------------+
|
| bool CEACore::Initialize(string symbol, ENUM_TIMEFRAMES timeframe, bool isBacktest = false)
|
| {
|
| if (m_isInitialized)
|
| {
|
| Print("EA Core already initialized");
|
| return true;
|
| }
|
|
|
| m_symbol = symbol;
|
| m_timeframe = timeframe;
|
| m_isBacktest = isBacktest;
|
|
|
| if (!InitializeComponents())
|
| {
|
| Print("Failed to initialize EA Core components");
|
| return false;
|
| }
|
|
|
| m_isInitialized = true;
|
| Print("EA Core initialized successfully");
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Deinitialize EA core |
|
| //+------------------------------------------------------------------+
|
| void CEACore::Deinitialize()
|
| {
|
| if (!m_isInitialized)
|
| return;
|
|
|
| CleanupComponents();
|
| m_isInitialized = false;
|
| Print("EA Core deinitialized");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize all components |
|
| //+------------------------------------------------------------------+
|
| bool CEACore::InitializeComponents()
|
| {
|
| // Initialize logger first
|
| m_logger = new CEALogger();
|
| if (!m_logger.Initialize("EALog.txt"))
|
| {
|
| Print("Failed to initialize logger");
|
| return false;
|
| }
|
|
|
| // Initialize state manager
|
| m_state = new CEAState();
|
| if (!m_state.Initialize(m_logger))
|
| {
|
| Print("Failed to initialize state manager");
|
| return false;
|
| }
|
|
|
| // Initialize event system
|
| m_events = new CEAEvents();
|
| if (!m_events.Initialize(m_logger, m_state))
|
| {
|
| Print("Failed to initialize event system");
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Cleanup all components |
|
| //+------------------------------------------------------------------+
|
| void CEACore::CleanupComponents()
|
| {
|
| if (m_events != NULL)
|
| {
|
| m_events.Deinitialize();
|
| delete m_events;
|
| m_events = NULL;
|
| }
|
|
|
| if (m_state != NULL)
|
| {
|
| m_state.Deinitialize();
|
| delete m_state;
|
| m_state = NULL;
|
| }
|
|
|
| if (m_logger != NULL)
|
| {
|
| m_logger.Deinitialize();
|
| delete m_logger;
|
| m_logger = NULL;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Process tick event |
|
| //+------------------------------------------------------------------+
|
| void CEACore::OnTick()
|
| {
|
| if (!m_isInitialized)
|
| return;
|
|
|
| try
|
| {
|
| HandleTick();
|
| }
|
| catch (const string error)
|
| {
|
| if (m_logger != NULL)
|
| m_logger.LogError("Error in OnTick: " + error);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Process timer event |
|
| //+------------------------------------------------------------------+
|
| void CEACore::OnTimer()
|
| {
|
| if (!m_isInitialized)
|
| return;
|
|
|
| try
|
| {
|
| HandleTimer();
|
| }
|
| catch (const string error)
|
| {
|
| if (m_logger != NULL)
|
| m_logger.LogError("Error in OnTimer: " + error);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Process trade event |
|
| //+------------------------------------------------------------------+
|
| void CEACore::OnTrade()
|
| {
|
| if (!m_isInitialized)
|
| return;
|
|
|
| try
|
| {
|
| HandleTrade();
|
| }
|
| catch (const string error)
|
| {
|
| if (m_logger != NULL)
|
| m_logger.LogError("Error in OnTrade: " + error);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Handle tick processing |
|
| //+------------------------------------------------------------------+
|
| void CEACore::HandleTick()
|
| {
|
| // Process pending events
|
| if (m_events != NULL)
|
| m_events.ProcessTick();
|
|
|
| // Update state with latest market data
|
| if (m_state != NULL)
|
| m_state.UpdateMarketData(m_symbol, m_timeframe);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Handle timer processing |
|
| //+------------------------------------------------------------------+
|
| void CEACore::HandleTimer()
|
| {
|
| // Process timed events
|
| if (m_events != NULL)
|
| m_events.ProcessTimer();
|
|
|
| // Update state periodically
|
| if (m_state != NULL)
|
| m_state.UpdateIndicators();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Handle trade processing |
|
| //+------------------------------------------------------------------+
|
| void CEACore::HandleTrade()
|
| {
|
| // Process trade-related events
|
| if (m_events != NULL)
|
| m_events.ProcessTrade();
|
|
|
| // Update state with latest trade information
|
| if (m_state != NULL)
|
| m_state.UpdateTradeState();
|
| }
|
