last ...

Classes/x-saherelm.xea.class.mq5

@@ -21,6 +21,7 @@
 
 //
 // Imports ...
+#include <Generic/HashMap.mqh>
 #include "../Classes/x-saherelm.base.class.mq5"
 #include "../Classes/x-saherelm.xalert.class.mq5"
 #include "../Classes/x-saherelm.xtrade.class.mq5"
@@ -1265,6 +1266,870 @@ private:
     }
 };
 
+//
+class XSCPositionHolder
+{
+    //
+    // Public ...
+public:
+    //
+    // Props ...
+
+    //
+    // Constructor(s) ...
+
+    //
+    XSCPositionHolder()
+    {
+        Clear();
+    }
+
+    //
+    // Tools ...
+
+    //
+    // Cleanup ...
+    void Clear()
+    {
+        Clean(mItems);
+    }
+
+    //
+    bool AddItem(XPosition &item)
+    {
+        //
+        bool result = false;
+
+        //
+        result = item.IsValid();
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        result = !HasItem(item);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        AddRef(
+            item,
+            mItems //
+        );
+
+        //
+        return result;
+    }
+
+    //
+    int AddItems(XPosition &items[])
+    {
+        //
+        int result = 0;
+
+        //
+        int itemsCount = ArraySize(items);
+        if (itemsCount <= 0)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = items[i];
+
+            //
+            bool isAdded = AddItem(iItem);
+            if (isAdded)
+            {
+                result++;
+            }
+        }
+
+        //
+        return result;
+    }
+
+    //
+    bool AddOrUpdateItem(XPosition &item)
+    {
+        //
+        bool result = false;
+
+        //
+        result = item.IsValid();
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        bool hasItem = HasItem(item);
+        if (!hasItem)
+        {
+            result = AddItem(item);
+        }
+        else
+        {
+            //
+            result = RemoveItem(item);
+            if (result)
+            {
+                result = AddItem(item);
+            }
+        }
+
+        //
+        return result;
+    }
+
+    //
+    int AddOrUpdateItem(XPosition &items[])
+    {
+        //
+        int result = 0;
+
+        //
+        int itemsCount = ArraySize(items);
+        if (itemsCount <= 0)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = items[i];
+
+            //
+            bool isAddOrUpdated = AddOrUpdateItem(iItem);
+            if (isAddOrUpdated)
+            {
+                result++;
+            }
+        }
+
+        //
+        return result;
+    }
+
+    //
+    bool HasItem(XPosition &item)
+    {
+        //
+        bool result = false;
+
+        //
+        int itemIDX = FindItem(item);
+        result = itemIDX >= 0;
+
+        //
+        return result;
+    }
+
+    //
+    int FindItem(XPosition &item)
+    {
+        //
+        int result = -1;
+
+        //
+        if (!item.IsValid())
+        {
+            return result;
+        }
+
+        //
+        int itemsCount = CountItems();
+        if (itemsCount <= 0)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool isSame = IsItemSameAs(item, iItem);
+            if (isSame)
+            {
+                //
+                result = i;
+                break;
+            }
+        }
+
+        //
+        return result;
+    }
+
+    //
+    bool GetByIndex(
+        int index,
+        XPosition &item //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        NormalizeIndex(
+            index,
+            mItems //
+        );
+
+        //
+        item = mItems[index];
+
+        //
+        result = item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool RemoveItem(XPosition &item)
+    {
+        //
+        bool result = false;
+
+        //
+        result = HasItem(item);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        int itemIDX = FindItem(item);
+        result = ArrayRemove(
+            mItems,
+            itemIDX,
+            1 //
+        );
+
+        //
+        return result;
+    }
+
+    //
+    int RemoveItems(XPosition &items[])
+    {
+        //
+        int result = 0;
+
+        //
+        int itemsCount = ArraySize(items);
+        if (itemsCount <= 0)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = items[i];
+
+            //
+            bool isRemoved = RemoveItem(iItem);
+            if (isRemoved)
+            {
+                result++;
+            }
+        }
+
+        //
+        return result;
+    }
+
+    //
+    int CountItems()
+    {
+        return ArraySize(mItems);
+    }
+
+    //
+    bool IsItemSameAs(
+        XPosition &source,
+        XPosition &dest // Compare Source with this ...
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        result =
+            //
+            dest.IsValid() &&
+            source.IsValid() &&
+            source.symbol == dest.symbol &&
+            source.period == dest.period &&
+            source.ticket == dest.ticket &&
+            source.openAt == dest.openAt &&
+            source.provider == dest.provider
+            //
+            ;
+
+        //
+        return result;
+    }
+
+    //
+    // Custom Functions ...
+
+    //
+    bool GetMaxInDrawdown(
+        XPosition &item // Result
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        int maxIDX = -1;
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool canSelect =
+                //
+                iItem.profit < 0
+                //
+                &&
+                //
+                (
+                    //
+                    (maxIDX == -1 && !item.IsValid())
+                        ? true
+                        : item.profit < iItem.profit
+                    //
+                    )
+                //
+                ;
+            if (canSelect)
+            {
+                //
+                maxIDX = i;
+                item = iItem;
+            }
+        }
+
+        //
+        result = maxIDX > -1 && item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool GetMaxInProfit(
+        XPosition &item // Result
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        int maxIDX = -1;
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool canSelect =
+                //
+                iItem.profit > 0
+                //
+                &&
+                //
+                (
+                    //
+                    (maxIDX == -1 && !item.IsValid())
+                        ? true
+                        : item.profit < iItem.profit
+                    //
+                    )
+                //
+                ;
+            if (canSelect)
+            {
+                //
+                maxIDX = i;
+                item = iItem;
+            }
+        }
+
+        //
+        result = maxIDX > -1 && item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool GetFarestEntry(
+        XPosition &item, // Result
+        string symbol = NULL,
+        string provider = NULL,
+        ENUM_TIMEFRAMES period = NULL,
+        ENUM_POSITION_TYPE type = NULL //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool isFiltersPassed =
+                //
+                iItem.IsFiltersPassed(
+                    symbol,
+                    provider,
+                    period,
+                    type //
+                    )
+                //
+                ;
+
+            //
+            if (!isFiltersPassed)
+            {
+                continue;
+            }
+
+            //
+            // Do Additional Filtering ...
+            bool isValidEntry =
+                //
+                !item.IsValid()
+                    ? true
+                    : item.entry < iItem.entry
+                //
+                ;
+            if (isValidEntry)
+            {
+                //
+                item = iItem;
+            }
+        }
+
+        //
+        result = item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool GetNearestEntry(
+        XPosition &item, // Result
+        string symbol = NULL,
+        string provider = NULL,
+        ENUM_TIMEFRAMES period = NULL,
+        ENUM_POSITION_TYPE type = NULL //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool isFiltersPassed =
+                //
+                iItem.IsFiltersPassed(
+                    symbol,
+                    provider,
+                    period,
+                    type //
+                    )
+                //
+                ;
+
+            //
+            if (!isFiltersPassed)
+            {
+                continue;
+            }
+
+            //
+            // Do Additional Filtering ...
+            bool isValidEntry =
+                //
+                !item.IsValid()
+                    ? true
+                    : item.entry > iItem.entry
+                //
+                ;
+            if (isValidEntry)
+            {
+                //
+                item = iItem;
+            }
+        }
+
+        //
+        result = item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool GetFarestSL(
+        XPosition &item, // Result
+        string symbol = NULL,
+        string provider = NULL,
+        ENUM_TIMEFRAMES period = NULL,
+        ENUM_POSITION_TYPE type = NULL //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool isFiltersPassed =
+                //
+                iItem.IsFiltersPassed(
+                    symbol,
+                    provider,
+                    period,
+                    type //
+                    )
+                //
+                ;
+
+            //
+            if (!isFiltersPassed)
+            {
+                continue;
+            }
+
+            //
+            // Do Additional Filtering ...
+            bool isValidEntry =
+                //
+                !item.IsValid()
+                    ? true
+                    : item.sl < iItem.sl
+                //
+                ;
+            if (isValidEntry)
+            {
+                //
+                item = iItem;
+            }
+        }
+
+        //
+        result = item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool GetNearestSL(
+        XPosition &item, // Result
+        string symbol = NULL,
+        string provider = NULL,
+        ENUM_TIMEFRAMES period = NULL,
+        ENUM_POSITION_TYPE type = NULL //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool isFiltersPassed =
+                //
+                iItem.IsFiltersPassed(
+                    symbol,
+                    provider,
+                    period,
+                    type //
+                    )
+                //
+                ;
+
+            //
+            if (!isFiltersPassed)
+            {
+                continue;
+            }
+
+            //
+            // Do Additional Filtering ...
+            bool isValidEntry =
+                //
+                !item.IsValid()
+                    ? true
+                    : item.sl > iItem.sl
+                //
+                ;
+            if (isValidEntry)
+            {
+                //
+                item = iItem;
+            }
+        }
+
+        //
+        result = item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool GetFarestTP(
+        XPosition &item, // Result
+        string symbol = NULL,
+        string provider = NULL,
+        ENUM_TIMEFRAMES period = NULL,
+        ENUM_POSITION_TYPE type = NULL //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool isFiltersPassed =
+                //
+                iItem.IsFiltersPassed(
+                    symbol,
+                    provider,
+                    period,
+                    type //
+                    )
+                //
+                ;
+
+            //
+            if (!isFiltersPassed)
+            {
+                continue;
+            }
+
+            //
+            // Do Additional Filtering ...
+            bool isValidEntry =
+                //
+                !item.IsValid()
+                    ? true
+                    : item.tp < iItem.tp
+                //
+                ;
+            if (isValidEntry)
+            {
+                //
+                item = iItem;
+            }
+        }
+
+        //
+        result = item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    bool GetNearestTP(
+        XPosition &item, // Result
+        string symbol = NULL,
+        string provider = NULL,
+        ENUM_TIMEFRAMES period = NULL,
+        ENUM_POSITION_TYPE type = NULL //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        item.Clean();
+
+        //
+        int itemsCount = CountItems();
+        result = IsValidSize(itemsCount);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        for (int i = 0; i < itemsCount; i++)
+        {
+            //
+            XPosition iItem = mItems[i];
+
+            //
+            bool isFiltersPassed =
+                //
+                iItem.IsFiltersPassed(
+                    symbol,
+                    provider,
+                    period,
+                    type //
+                    )
+                //
+                ;
+
+            //
+            if (!isFiltersPassed)
+            {
+                continue;
+            }
+
+            //
+            // Do Additional Filtering ...
+            bool isValidEntry =
+                //
+                !item.IsValid()
+                    ? true
+                    : item.tp > iItem.tp
+                //
+                ;
+            if (isValidEntry)
+            {
+                //
+                item = iItem;
+            }
+        }
+
+        //
+        result = item.IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    // Private ...
+private:
+    //
+    // Props ...
+    XPosition mItems[];
+};
+
 //
 // Class Definition ...
 
@@ -2973,6 +3838,87 @@ protected:
         }
     }
 
+    //
+    // Position Filter ...
+
+    //
+    int FilterSymbolBasedPositions(
+        string &symbols[],            // Hold Symbols ...
+        XSCPositionHolder *&holders[] // Holder Class Instances ...
+    )
+    {
+        //
+        int result = 0;
+
+        //
+        XPosition positions[];
+        int positionsCount = mTrader.GetPositions(
+            positions //
+        );
+        if (!IsValidSize(positionsCount))
+        {
+            return result;
+        }
+
+        //
+        // Create a HashMap for Holding Positions ...
+        CHashMap<string, XSCPositionHolder *> symbolMap;
+
+        //
+        // Loop Through Positions ...
+        for (int i = 0; i < positionsCount; i++)
+        {
+            //
+            XPosition iPosition = positions[i];
+
+            //
+            bool hasIKey = symbolMap.ContainsKey(iPosition.symbol);
+
+            //
+            // Empty Class Pointer ...
+            XSCPositionHolder *mHolder = NULL;
+
+            //
+            // Add new to Map ...
+            if (!hasIKey)
+            {
+                //
+                mHolder = new XSCPositionHolder();
+                if (symbolMap.TrySetValue(iPosition.symbol, mHolder))
+                {
+                    mHolder.AddOrUpdateItem(iPosition);
+                }
+            }
+            //
+            // Update Exists in Map ...
+            else
+            {
+                //
+                if (symbolMap.TryGetValue(iPosition.symbol, mHolder))
+                {
+                    mHolder.AddOrUpdateItem(iPosition);
+                }
+            }
+        }
+
+        //
+        // Now we Have a Map which Filled Based on Separate Symbols and InDrawDown Positions ...
+        int mapCount = symbolMap.Count();
+        if (!IsValidSize(mapCount))
+        {
+            return result;
+        }
+
+        //
+        result = symbolMap.CopyTo(
+            symbols,
+            holders //
+        );
+
+        //
+        return result;
+    }
+
     //
     // Private ...
 private:

Experts/x-test.x121ea.mq5

@@ -31,14 +31,14 @@
 
 //
 // Inputs ...
-long x121EAMagicNumber = 78692110;                                                        // Magic Number
+long x121EAMagicNumber = 78692110;                        // Magic Number
-int x121EASlippage = 10;                                                                  // Slippgae
+int x121EASlippage = 10;                                  // Slippgae
-string x121EASymbols = "EURUSDb,USDCHFb,USDJPYb,GBPUSDb,XAUUSDb,AUDUSDb,USDCADb,NZDUSDb"; // Symbols
+string x121EASymbols = "EURUSDb,USDCHFb,USDJPYb,GBPUSDb"; // Symbols
 //
 bool x121EAAllowLong = true;                   // Allow Long Trades
 bool x121EAAllowShort = true;                  // Allow Short Trades
 int x121EAManageInterval = 0;                  // Manager Check Intervals Seconds
-int x121EAMaxAllowedPositions = 10;            // Max Allowed Positions
+int x121EAMaxAllowedPositions = 5;            // Max Allowed Positions
 double x121EAMaxAllowedSpread = 0;             // Max Allowed Spred for Opening Trades
 double x121EAMinProfitPerTrade = 3;            // Min Profit Per Trade based On Volume Factor (Hedge)
 double x121EAMinProfitPerVolumeFactor = 0.01;  // Min Volume Factor for Calculating Profit (Hedge)
@@ -291,7 +291,7 @@ void ConfigureDescriptor(
     //
     // XHK ...
     iDescriptor.inputs.hkInputs.drawHikenAshi = false;
-    iDescriptor.inputs.hkInputs.drawSmoothedHikenAshi = true;
+    iDescriptor.inputs.hkInputs.drawSmoothedHikenAshi = false;
 
     //
     // XMC ...