Learn New MQL Coding

Quoting lucklogic

Disliked

But never mind if you don't feel capable of doing it, there is always more than one way to skin a cat

Ignored

Quoting lucklogic

Disliked

Actually I made the request in exactly the same fashion that promoted you to develop Renko charts code : "Hi Sir, sorry for my bad English, is it possible to create offline chart /renko chart builder indicator with full OOP and make it more lighter for CPU, since the current offline chart builder (including mine), use a lot of CPU resources due to read/write hst file process ? Really appreciate your guidance, and ready to learn from the beginning.. Thank You In Advance." The old code that I supplied was actually the state of the art in basket creation...

Ignored

static void          Destroy();

void RenkoChart::Destroy() {
   if( m_pInstance != NULL ){
      delete m_pInstance;
   }
   m_pInstance = NULL;
}

void OnDeinit( const int reason ){
   RenkoChart::Instance().OnDeinit();
   RenkoChart::Destroy();
}

Quoting iwjw

Disliked

delete Instance() is what I'm using in OnDeinit and that solved the problem On thing I also changed in ComputeCurrentBar is that I set m_Rate.m_Time only once It's reset to zero in OnCalculate when the candle has finished and set to Time[0] later

Ignored

Quoting iwjw

Disliked

I would like to test strategies where multiple currencies are involved Due to the limitations of the MT4 tester, an indicator, that acts as a trade simulator comes into my mind What I would like to know is how to start Would a trade be mapped into a structure or would it be better to use a class that containes the trade properties Is there one "superclass" that handles all, or would it make sense to sepaerate positions, orders and history How would the position management look like An Array of structures/classes that would have to be always resized/resorted...

Ignored

Quoting iwjw

Disliked

Would a trade be mapped into a structure or would it be better to use a class that containes the trade properties

Ignored

Quoting iwjw

Disliked

Is there one "superclass" that handles all, or would it make sense to sepaerate positions, orders and history

Ignored

Quoting iwjw

Disliked

How would the position management look like An Array of structures/classes that would have to be always resized/resorted when a position is added/removed? Or is there an more elegant way to remove a position?

Ignored

Quoting iwjw

Disliked

So if I wanted to use CList I would have to declare class Order : public CObject and then could manage the Orderlist with the methods of CList?

Ignored

Quoting iwjw

Disliked

So if I wanted to use CList I would have to declare class Order : public CObject and then could manage the Orderlist with the methods of CList?

Ignored

Quoting iwjw

Disliked

ok, again thanks for your help before I start reinventing the wheel, I will have a look at this implementation http://www.mql5.com/en/articles/88 It's developed for mql5 but I hope there's nothing in it that isn't availlable with mql4

Ignored

Quoting Halley

Disliked

{quote} Probably. The trouble is that the libraries which you talk about were created by MQ. They are not common standard. About 3 months ago I looked into them once and what I found was annoying. I avoided them entirely. Perhaps we may create own simple list and iterator implementation in one of our OOP lessons.

Ignored

/****************************************************************************************
   Class ListNode
   All objects being listed need to be derived from this class.
****************************************************************************************/
class ListNode {
   ListNode* m_pNext;
   ListNode* m_pPrev;
  
   public:
      ListNode(){
         m_pNext = m_pPrev = NULL;
      }
};

/****************************************************************************************
   Class List
   Manages a list of ListNodes objects.
****************************************************************************************/
class List{
 
   ListNode*      m_pBegin;
   ListNode*      m_pEnd;
  
   public:
                  List();
  
};
 
 
 
 
/****************************************************************************************
   List()
   Class Constructor.
****************************************************************************************/
List::List(){
   m_pBegin = NULL;
   // We use an empty node that will serve to know when we are at the end of the list.
   m_pEnd = new ListNode();
}

/****************************************************************************************
   Class ListNode
   All objects being listed need to be derived from this class.
****************************************************************************************/
class ListNode {
   ListNode* m_pNext;
   ListNode* m_pPrev;
  
   public:
      ListNode(){
         m_pNext = m_pPrev = NULL;
      }
    
      // Next, Updates, Retrieves the next node.
      ListNode* Next( ListNode* next=NULL ){
         if( next != NULL ){
            m_pNext = next;
         }
         return m_pNext;
      }
    
      // Prev, Updates, Retrieves the previous node.
      ListNode* Prev( ListNode*prev=NULL ){
         if( prev != NULL ){
            m_pPrev = prev;
         }
         return m_pPrev;
      }
    
};

      ListNode*   Begin();
      ListNode*   End();
      bool        Insert( ListNode* where, ListNode* node );

/****************************************************************************************
   Insert( ListNode* where, ListNode* node )
   Inserts a node in the List
   where, ListNode object pointer which represents the insertion point.
   node, ListNode object pointer to be inserted.
****************************************************************************************/
bool List::Insert( ListNode* where, ListNode* node ) {
 
   // We don't allow duplicates.    
   if( Contains( node ) ){
      return false;
   }  
 
   // Handle special case of empty list.
   if( (where == NULL && m_pBegin == NULL) || (where==m_pEnd && m_pBegin == NULL) ){
      m_pBegin = node;
      m_pBegin.Next( m_pEnd );
      m_pEnd.Prev( m_pBegin );
      return true;
   }
 
   // We don't allow inserting at a node not already present in our list
   if( ! Contains( where ) ){
      return false;
   }  
 
   // Handle special where the insertion point is the begining of the list.
   if( where == m_pBegin ){
      node.Next( m_pBegin );
      m_pBegin.Prev( node );
      m_pBegin = node;
      return true;
   }
  
   // any other case
   where.Prev().Next( node );
   node.Prev( where.Prev() );
   node.Next( where );
   where.Prev( node );
   return true;
}

/****************************************************************************************
   Contains( ListNode* node )
   Checks if a node is present in the list.
   node, the ListNode object for which the presence has to be checked.
****************************************************************************************/
bool List::Contains( ListNode* node ) {
  
   ListNode* pN = m_pBegin;
  
   // Empty list check.
   if( pN == NULL ){
      return false;
   }
  
   for( ; pN != m_pEnd; pN = pN.Next() ){
      if( pN == node ){
         return true;
      }
   }
   return false;
}

class ListedObject : public ListNode {
   string m_Name;
  
   public:
      ListedObject( string name ){
         m_Name = name;
      }  
    
      string Name() { return m_Name; }
};

/****************************************************************************************
   OnInit()
   Initializes Indicator Global Variables
****************************************************************************************/
int OnInit() {
 
   // Our List object
   List MyList;
  
   // Some simple objects to put in our list
   ListedObject* First = new ListedObject( "First Object" );
   ListedObject* Second = new ListedObject( "Second Object" );
   ListedObject* Third = new ListedObject( "Third Object" );
  
   // Insert Third object at the end of the list
   MyList.Insert( MyList.End(), Third );
  
   // Insert First object at the begining of the list
   MyList.Insert( MyList.Begin(), First  );
 
   // Insert Second object before Third
   MyList.Insert( Third, Second );
  
   // Iterate through our list
   ListedObject* pLO;
   for( ListNode* pN = MyList.Begin(); pN!= MyList.End(); pN = pN.Next() ){
      pLO = (ListedObject*) pN;
      Print( pLO.Name() );
   }
 
   return INIT_SUCCEEDED;
}

/****************************************************************************************
   Remove( ListNode* node )
   Removes (unlink) a node from the list.
   node, The ListNode object to be removed from the list
****************************************************************************************/
bool List::Remove( ListNode* node ) {
  
   // If node not in the list, nothing to do.
   if( ! Contains(node) ){
      return false;
   }
  
   // Special case where the node is the begin of the list.
   if( node == m_pBegin ){
      if( node.Next() == m_pEnd ){
         // Last node, just set begin pointer to NULL.
         m_pBegin = NULL;
      }
      else{
         m_pBegin = node.Next();
         m_pBegin.Prev( NULL );
      }
      return true;
   }
  
   // Update link pointers.
   node.Prev().Next( node.Next() );
   node.Next().Prev( node.Prev() );
   return true;  
}

/****************************************************************************************
   Count()
   Returns the number of objects in the list.
****************************************************************************************/
int List::Count() {
   int Count = 0;
 
   for( ListNode* pN = m_pBegin; pN != NULL && pN != m_pEnd; pN = pN.Next() ) {
      Count++;
   }
 
   return Count;  
}