//+------------------------------------------------------------------+
//|                                                     TreeNode.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <Object.mqh>
//+------------------------------------------------------------------+
//| Class CTreeNode.                                                 |
//| Purpose: Base class of node of binary tree CTree.                |
//|          Derives from class CObject.                             |
//+------------------------------------------------------------------+
class CTreeNode : public CObject
  {
private:
   CTreeNode        *m_p_node;             // link to node up
   CTreeNode        *m_l_node;             // link to node left
   CTreeNode        *m_r_node;             // link to node right
   //--- variables
   int               m_balance;            // balance of node
   int               m_l_balance;          // balance of the left branch
   int               m_r_balance;          // balance of the right branch

public:
                     CTreeNode(void);
                    ~CTreeNode(void);
   //--- methods of access to protected data
   CTreeNode*        Parent(void)           const { return(m_p_node);    }
   void              Parent(CTreeNode *node)      { m_p_node=node;       }
   CTreeNode*        Left(void)             const { return(m_l_node);    }
   void              Left(CTreeNode *node)        { m_l_node=node;       }
   CTreeNode*        Right(void)            const { return(m_r_node);    }
   void              Right(CTreeNode *node)       { m_r_node=node;       }
   int               Balance(void)          const { return(m_balance);   }
   int               BalanceL(void)         const { return(m_l_balance); }
   int               BalanceR(void)         const { return(m_r_balance); }
   //--- method of identifying the object
   virtual int       Type(void) const { return(0x8888); }
   //--- methods for controlling
   int               RefreshBalance(void);
   CTreeNode        *GetNext(const CTreeNode *node);
   //--- methods for working with files
   bool              SaveNode(const int file_handle);
   bool              LoadNode(const int file_handle,CTreeNode *main);

protected:
   //--- method for creating an instance of class
   virtual CTreeNode *CreateSample(void) { return(NULL); }
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CTreeNode::CTreeNode(void) : m_p_node(NULL),
                             m_l_node(NULL),
                             m_r_node(NULL),
                             m_balance(0),
                             m_l_balance(0),
                             m_r_balance(0)
  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CTreeNode::~CTreeNode(void)
  {
//--- delete nodes of the next level
   if(m_l_node!=NULL)
      delete m_l_node;
   if(m_r_node!=NULL)
      delete m_r_node;
  }
//+------------------------------------------------------------------+
//| Calculating the balance of the node                              |
//+------------------------------------------------------------------+
int CTreeNode::RefreshBalance(void)
  {
//--- calculate the balance of the left branch
   if(m_l_node==NULL)
      m_l_balance=0;
   else
      m_l_balance=m_l_node.RefreshBalance();
//--- calculate the balance of the right branch
   if(m_r_node==NULL)
      m_r_balance=0;
   else
      m_r_balance=m_r_node.RefreshBalance();
//--- calculate the balance of the node
   if(m_r_balance>m_l_balance)
      m_balance=m_r_balance+1;
   else
      m_balance=m_l_balance+1;
//--- result
   return(m_balance);
  }
//+------------------------------------------------------------------+
//| Selecting next node                                              |
//+------------------------------------------------------------------+
CTreeNode *CTreeNode::GetNext(const CTreeNode *node)
  {
   if(Compare(node)>0)
      return(m_l_node);
//--- result
   return(m_r_node);
  }
//+------------------------------------------------------------------+
//| Writing node data to file                                        |
//+------------------------------------------------------------------+
bool CTreeNode::SaveNode(const int file_handle)
  {
   bool result=true;
//--- check
   if(file_handle==INVALID_HANDLE)
      return(false);
//--- write left node (if it is available)
   if(m_l_node!=NULL)
     {
      FileWriteInteger(file_handle,'L',SHORT_VALUE);
      result&=m_l_node.SaveNode(file_handle);
     }
   else
      FileWriteInteger(file_handle,'X',SHORT_VALUE);
//--- write data of current node
   result&=Save(file_handle);
//--- write right node (if it is available)
   if(m_r_node!=NULL)
     {
      FileWriteInteger(file_handle,'R',SHORT_VALUE);
      result&=m_r_node.SaveNode(file_handle);
     }
   else
      FileWriteInteger(file_handle,'X',SHORT_VALUE);
//--- successful
   return(true);
  }
//+------------------------------------------------------------------+
//| Reading node data from file                                      |
//+------------------------------------------------------------------+
bool CTreeNode::LoadNode(const int file_handle,CTreeNode *main)
  {
   bool       result=true;
   short      s_val;
   CTreeNode *node;
//--- check
   if(file_handle==INVALID_HANDLE)
      return(false);
//--- read directions
   s_val=(short)FileReadInteger(file_handle,SHORT_VALUE);
   if(s_val=='L')
     {
      //--- read left node (if there is data)
      node=CreateSample();
      if(node==NULL)
         return(false);
      m_l_node=node;
      node.Parent(main);
      result&=node.LoadNode(file_handle,node);
     }
//--- read data of current node
   result&=Load(file_handle);
//--- read directions
   s_val=(short)FileReadInteger(file_handle,SHORT_VALUE);
   if(s_val=='R')
     {
      //--- read right node (if there is data)
      node=CreateSample();
      if(node==NULL)
         return(false);
      m_r_node=node;
      node.Parent(main);
      result&=node.LoadNode(file_handle,node);
     }
//--- result
   return(result);
  }
//+------------------------------------------------------------------+