last ...

Libraries/x-saherelm.x-poi.extensions.lib.mq5

@@ -1908,7 +1908,7 @@ void SortZones(
         if (!hasLast)
         {
             //
-            idx = GetYoungest(source);
+            idx = GetOldest(source);
             hasLast = IsValidIndex(idx);
             if (hasLast)
             {
@@ -1923,7 +1923,7 @@ void SortZones(
                 //
                 Add(
                     last,
-                    source //
+                    tmpItems //
                 );
             }
 
@@ -1946,7 +1946,7 @@ void SortZones(
 
         //
         T *item = NULL;
-        idx = GetYoungest(source);
+        idx = GetOldest(source);
         has = IsValidIndex(idx);
         if (!has)
         {
@@ -3548,7 +3548,7 @@ void Sort(
         if (!hasLast)
         {
             //
-            idx = GetYoungest(source);
+            idx = GetOldest(source);
             hasLast = IsValidIndex(idx);
             if (hasLast)
             {
@@ -3563,7 +3563,7 @@ void Sort(
                 //
                 AddRef(
                     last,
-                    source //
+                    tmpItems //
                 );
             }
 
@@ -3580,13 +3580,13 @@ void Sort(
         if (!hasLast)
         {
             //
-            ZeroMemory(last);
+            last.Clean();
             break;
         }
 
         //
         XOBFVG item;
-        idx = GetYoungest(source);
+        idx = GetOldest(source);
         has = IsValidIndex(idx);
         if (!has)
         {

Libraries/x-saherelm.x-poi.lib.mq5

@@ -6639,6 +6639,196 @@ struct XOBFVG
         return result;
     }
 
+    //
+    void UpdateZones(
+        XPOIState &state //
+    )
+    {
+        //
+        Clean(supplyZones);
+        Clean(demandZones);
+        Clean(supportZones);
+        Clean(resistanceZones);
+
+        //
+        bool isValid =
+            IsValid() &&
+            state.HasChild();
+        if (!isValid)
+        {
+            return;
+        }
+
+        //
+        int count = 0;
+        bool has = false;
+        bool isPassed = false;
+
+        //
+        // Supply Zones ...
+        has = state.HasSupplyZones();
+        if (has)
+        {
+            //
+            count = state.CountSupplyZones();
+            for (int i = 0; i < count; i++)
+            {
+                //
+                XCSupplyZone *iZone = state.supplyZones[i];
+
+                //
+                isPassed = iZone.From() > ob.From();
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                isPassed = IsInsideDiff(
+                    iZone,
+                    ob //
+                );
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                Add(
+                    iZone,
+                    supplyZones //
+                );
+            }
+        }
+
+        //
+        // Demand Zones ...
+        has = state.HasDemandZones();
+        if (has)
+        {
+            //
+            count = state.CountDemandZones();
+            for (int i = 0; i < count; i++)
+            {
+                //
+                XCDemandZone *iZone = state.demandZones[i];
+
+                //
+                isPassed = iZone.From() > ob.From();
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                isPassed = IsInsideDiff(
+                    iZone,
+                    ob //
+                );
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                Add(
+                    iZone,
+                    demandZones //
+                );
+            }
+        }
+
+        //
+        // Support Zones ...
+        has = state.HasSupportZones();
+        if (has)
+        {
+            //
+            count = state.CountSupportZones();
+            for (int i = 0; i < count; i++)
+            {
+                //
+                XCSupportZone *iZone = state.supportZones[i];
+
+                //
+                isPassed = iZone.From() > ob.From();
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                isPassed = IsInsideDiff(
+                    iZone,
+                    ob //
+                );
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                Add(
+                    iZone,
+                    supportZones //
+                );
+            }
+        }
+
+        //
+        // Resistance Zones ...
+        has = state.HasResistanceZones();
+        if (has)
+        {
+            //
+            count = state.CountResistanceZones();
+            for (int i = 0; i < count; i++)
+            {
+                //
+                XCResistanceZone *iZone = state.resistanceZones[i];
+
+                //
+                isPassed = iZone.From() > ob.From();
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                isPassed = IsInsideDiff(
+                    iZone,
+                    ob //
+                );
+                if (!isPassed)
+                {
+                    //
+                    ZeroMemory(iZone);
+                    continue;
+                }
+
+                //
+                Add(
+                    iZone,
+                    resistanceZones //
+                );
+            }
+        }
+    }
+
     //
     void UpdateTo(datetime value = NULL)
     {

X121SMCEA/Signals/x-121.smc.xwz.signal.class.mq5

@@ -169,8 +169,16 @@ class XCX121SMCXWZSignalDetector : public XCBase
         );
         if (!result)
         {
+            //
+            Clean(decisionPoiEvents);
+            Clean(decisionCycleEvents);
+
+            //
+            decisionConditions.Clean();
+
             //
             mConditions.Clean();
+            consolidationZBar.Clean();
 
             //
             return result;
@@ -190,8 +198,21 @@ class XCX121SMCXWZSignalDetector : public XCBase
         );
         if (!result)
         {
+            //
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+
+            //
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+
+            //
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+
             //
             mConditions.Clean();
+            consolidationZBar.Clean();
 
             //
             return result;
@@ -211,8 +232,24 @@ class XCX121SMCXWZSignalDetector : public XCBase
         );
         if (!result)
         {
+            //
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
             //
             mConditions.Clean();
+            consolidationZBar.Clean();
 
             //
             return result;
@@ -232,8 +269,27 @@ class XCX121SMCXWZSignalDetector : public XCBase
         );
         if (!result)
         {
+            //
+            Clean(visionPoiEvents);
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(visionCycleEvents);
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            visionConditions.Clean();
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
             //
             mConditions.Clean();
+            consolidationZBar.Clean();
 
             //
             return result;
@@ -257,6 +313,195 @@ class XCX121SMCXWZSignalDetector : public XCBase
         // Setup Conditions ...
 
         //
+        // Choch Trading Senario ...
+        bool hasChochBullishConditions = false;
+        bool hasChochBearishConditions = false;
+
+        //
+        // Order Flow Side Trading Senario ...
+        bool hasOrderFlowhBullishConditions = false;
+        bool hasOrderFlowhBearishConditions = false;
+
+        //
+        // Trend Line Trading Senario ...
+        bool hasTrendLineBullishConditions = false;
+        bool hasTrendLineBearishConditions = false;
+
+        //
+        // Quarter Line Trading Senario ...
+        bool hasBQuarterLineBullishConditions = false;
+        bool hasBQuarterLineBearishConditions = false;
+
+        //
+        // Supply and Demand Trading Senario ...
+        bool hasSupDemBullishConditions = false;
+        bool hasSupDemBearishConditions = false;
+
+        //
+        // Support and Resistance Trading Senario ...
+        bool hasSupResBullishConditions = false;
+        bool hasSupResBearishConditions = false;
+
+        //
+        // Detect Working Zone ...
+        bool hasWorkingZone = workingZone.IsValid();
+        if (!hasWorkingZone)
+        {
+            hasWorkingZone = DetectWorkingZone(visionState);
+        }
+        result = hasWorkingZone;
+        if (!result)
+        {
+            //
+            Clean(visionPoiEvents);
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(visionCycleEvents);
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            visionState.Clean();
+            analyseState.Clean();
+            decisionState.Clean();
+            consolidationState.Clean();
+
+            //
+            visionConditions.Clean();
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
+            //
+            visionXConditions.Clean();
+            analyseXConditions.Clean();
+            decisionXConditions.Clean();
+            consolidationXConditions.Clean();
+
+            //
+            mConditions.Clean();
+            consolidationZBar.Clean();
+
+            //
+            return result;
+        }
+
+        //
+        // TODO: Remove this ...
+        UpdateTo(cTime);
+        DrawWorkingZone(
+            visionCycleHelper.mPOIDrawer //
+        );
+
+        //
+        // Detect Working Zone Destroy ...
+        bool isWorkingZoneDetroyed = workingZone.IsDestroyed();
+        result = !isWorkingZoneDetroyed;
+        if (!result)
+        {
+            //
+            workingZone.Clean();
+            mWorkingZoneObjects.Clear();
+
+            //
+            Clean(visionPoiEvents);
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(visionCycleEvents);
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            visionState.Clean();
+            analyseState.Clean();
+            decisionState.Clean();
+            consolidationState.Clean();
+
+            //
+            visionConditions.Clean();
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
+            //
+            visionXConditions.Clean();
+            analyseXConditions.Clean();
+            decisionXConditions.Clean();
+            consolidationXConditions.Clean();
+
+            //
+            mConditions.Clean();
+            consolidationZBar.Clean();
+
+            //
+            return result;
+        }
+
+        //
+        // Checking Target Zone Breaked ...
+        bool hasTargetZone = targetZone.IsValid();
+        if (hasTargetZone)
+        {
+            //
+            XOHCL bar;
+            bool isInited = bar.Init(
+                symbol,
+                period,
+                zIndex //
+            );
+
+            XOHCL cBar;
+            isInited =
+                isInited &&
+                bar.GetPreviousBar(cBar);
+
+            //
+            bool isBullish = targetZone.IsBullish();
+
+            //
+            bool isLowerBreaked =
+                //
+                bar.high < targetZone.ob.Lower() &&
+                cBar.high < targetZone.ob.Lower()
+                //
+                ;
+
+            //
+            bool isUpperBreaked =
+                //
+                bar.low > targetZone.ob.Upper() &&
+                cBar.low > targetZone.ob.Upper()
+                //
+                ;
+
+            //
+            bool isBreaked = isBullish
+                                 ? isLowerBreaked
+                                 : isUpperBreaked;
+            if (isBreaked)
+            {
+                //
+                mWorkingZoneObjects.Clear();
+                targetZone.Clean();
+
+                //
+                // TODO: Remove this ...
+                DrawWorkingZone(
+                    visionCycleHelper.mPOIDrawer //
+                );
+            }
+        }
+
+        //
+        // Detect Order Flow ...
         ENUM_X_DIRECTION trend = X_DIRECTION_NONE;
         bool hasOrderFlow = workingZone.HasOrderFlow(trend);
         if (!hasOrderFlow)
@@ -273,18 +518,55 @@ class XCX121SMCXWZSignalDetector : public XCBase
             );
             hasOrderFlow = IsValidSize(orderFlowCount);
         }
-
-        //
         result = hasOrderFlow;
         if (!result)
         {
+
             //
-            // TODO: Implement Clean ...
+            Clean(visionPoiEvents);
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(visionCycleEvents);
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            visionState.Clean();
+            analyseState.Clean();
+            decisionState.Clean();
+            consolidationState.Clean();
+
+            //
+            visionConditions.Clean();
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
+            //
+            visionXConditions.Clean();
+            analyseXConditions.Clean();
+            decisionXConditions.Clean();
+            consolidationXConditions.Clean();
+
+            //
+            mConditions.Clean();
+            consolidationZBar.Clean();
 
             //
             return result;
         }
 
+        //
+        // TODO: Remove this ...
+        UpdateTo(cTime);
+        DrawWorkingZone(
+            visionCycleHelper.mPOIDrawer //
+        );
+
         //
         isBullish = IsBullish(trend);
         isBearish = IsBearish(trend);
@@ -305,24 +587,6 @@ class XCX121SMCXWZSignalDetector : public XCBase
             amountPercent //
         );
 
-        //
-        // Has Order Flow ...
-        UpdateTo(cTime);
-
-        //
-        // TODO: Remove this ...
-
-        //
-        DrawWorkingZone(
-            visionCycleHelper.mPOIDrawer //
-        );
-
-        //
-        DrawConditions(
-            mConditions,
-            visionCycleHelper.mPOIDrawer //
-        );
-
         //
         // Checking Order Flow Break ...
         int breakedIDX = -1;
@@ -364,7 +628,38 @@ class XCX121SMCXWZSignalDetector : public XCBase
         if (!result)
         {
             //
-            // TODO: Implement Clean ...
+            Clean(visionPoiEvents);
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(visionCycleEvents);
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            visionState.Clean();
+            analyseState.Clean();
+            decisionState.Clean();
+            consolidationState.Clean();
+
+            //
+            visionConditions.Clean();
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
+            //
+            visionXConditions.Clean();
+            analyseXConditions.Clean();
+            decisionXConditions.Clean();
+            consolidationXConditions.Clean();
+
+            //
+            mConditions.Clean();
+            consolidationZBar.Clean();
 
             //
             return result;
@@ -438,6 +733,9 @@ class XCX121SMCXWZSignalDetector : public XCBase
             {
                 //
                 // TODO: Implement Order Flow Side Trading Senario ...
+                youngestOrderFlow
+                    .UpdateZones(decisionState);
+                    
             }
 
             //
@@ -809,13 +1107,31 @@ class XCX121SMCXWZSignalDetector : public XCBase
         // TODO: Implement Support and Resistance Trading Senario ...
 
         //
-        // TODO: these are Trends ...
+        // Summarize ...
-        isBullish = false;
-        isBearish = false;
 
         //
-        bool hasBullishConditions = false;
+        bool hasBullishConditions =
-        bool hasBearishConditions = false;
+            //
+            hasChochBullishConditions ||
+            hasSupDemBullishConditions ||
+            hasSupResBullishConditions ||
+            hasTrendLineBullishConditions ||
+            hasOrderFlowhBullishConditions ||
+            hasBQuarterLineBullishConditions
+            //
+            ;
+
+        //
+        bool hasBearishConditions =
+            //
+            hasChochBearishConditions ||
+            hasSupDemBearishConditions ||
+            hasSupResBearishConditions ||
+            hasTrendLineBearishConditions ||
+            hasOrderFlowhBearishConditions ||
+            hasBQuarterLineBearishConditions
+            //
+            ;
 
         //
         result =
@@ -823,15 +1139,8 @@ class XCX121SMCXWZSignalDetector : public XCBase
             hasBearishConditions;
 
         //
-        // TODO: Implement All Cleanups ...
+        if (result)
-
+        {
-        //
-        return result;
-
-        //
-        // Summarise Conditions ...
-        //
-
             //
             mConditions.dir = trend;
             mConditions.pivot = pivot;
@@ -841,34 +1150,45 @@ class XCX121SMCXWZSignalDetector : public XCBase
             mConditions.setupTime = cTime;
             mConditions.priority = priority;
             mConditions.amountPercent = amountPercent;
+        }
 
         //
-        mConditions.UpdateTo(cTime);
+        // Cleanups ...
 
         //
         Clean(visionPoiEvents);
         Clean(analysePoiEvents);
         Clean(decisionPoiEvents);
+        Clean(consolidationPoiEvents);
+
+        //
         Clean(visionCycleEvents);
         Clean(analyseCycleEvents);
         Clean(decisionCycleEvents);
-        Clean(consolidationPoiEvents);
         Clean(consolidationCycleEvents);
 
         //
         visionState.Clean();
         analyseState.Clean();
         decisionState.Clean();
+        consolidationState.Clean();
+
+        //
         visionConditions.Clean();
         analyseConditions.Clean();
-        visionXConditions.Clean();
-        consolidationState.Clean();
         decisionConditions.Clean();
+        consolidationConditions.Clean();
+
+        //
+        visionXConditions.Clean();
         analyseXConditions.Clean();
         decisionXConditions.Clean();
-        consolidationConditions.Clean();
         consolidationXConditions.Clean();
 
+        //
+        mConditions.Clean();
+        consolidationZBar.Clean();
+
         //
         return result;
     }
@@ -1891,6 +2211,89 @@ class XCX121SMCXWZSignalDetector : public XCBase
         return result;
     }
 
+    //
+    bool DetectWorkingZone(
+        XPOIState &ltfState //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        result = IsValid(symbol) &&
+                 IsValid(period);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        result = !workingZone.IsValid();
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        workingZone.symbol = symbol;
+        workingZone.period = period;
+
+        //
+        int idx = -1;
+        bool has = false;
+
+        //
+        has = ltfState.HasSupplyZones();
+        if (has)
+        {
+            //
+            idx = GetHighest(ltfState.supplyZones);
+            if (IsValidIndex(idx))
+            {
+                workingZone.supplyZone = ltfState.supplyZones[idx];
+            }
+        }
+
+        //
+        has = ltfState.HasDemandZones();
+        if (has)
+        {
+            //
+            idx = GetLowest(ltfState.demandZones);
+            if (IsValidIndex(idx))
+            {
+                workingZone.demandZone = ltfState.demandZones[idx];
+            }
+        }
+
+        //
+        bool hasWorkingZone = workingZone.HasSupplyZone() &&
+                              workingZone.HasDemandZone();
+        if (hasWorkingZone)
+        {
+            //
+            double upper = workingZone.supplyZone.Lower();
+            double lower = workingZone.demandZone.Upper();
+
+            //
+            double delta = ((upper - lower) / 100) * 25;
+
+            //
+            workingZone.quarter1 = upper - (1 * delta);
+            workingZone.quarter2 = upper - (2 * delta);
+            workingZone.quarter3 = upper - (3 * delta);
+
+            //
+            hasWorkingZone = workingZone.IsValid();
+        }
+
+        //
+        result = hasWorkingZone;
+
+        //
+        return result;
+    }
+
     //
     // Draw Functions ...
     //

X121SMCEA/Signals/x-121.smc.xwz.signal.lib.mq5

@@ -725,6 +725,89 @@ struct X121SMCStrategyXWZWorkingZone
         );
     }
 
+    //
+    bool IsDestroyed(
+        int barIndex = 0,
+        ENUM_TIMEFRAMES forPeriod = NULL //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        if (barIndex < 0)
+        {
+            barIndex = 0;
+        }
+
+        //
+        if (!IsValid(forPeriod))
+        {
+            forPeriod = period;
+        }
+
+        //
+        result = IsValid();
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        XOHCL bar;
+        result = bar.Init(
+            symbol,
+            period,
+            barIndex //
+        );
+        if (!result)
+        {
+            //
+            bar.Clean();
+            return result;
+        }
+
+        //
+        XOHCL cBar;
+        result = bar.GetPreviousBar(cBar);
+        if (!result)
+        {
+            //
+            bar.Clean();
+            cBar.Clean();
+
+            //
+            return result;
+        }
+
+        //
+        bool isSupplyZoneBreaked =
+            //
+            bar.low > supplyZone.Upper() &&
+            cBar.low > supplyZone.Upper()
+            //
+            ;
+
+        //
+        bool isDemandZoneBreaked =
+            //
+            bar.high < demandZone.Lower() &&
+            cBar.high < demandZone.Lower()
+            //
+            ;
+
+        //
+        bar.Clean();
+        cBar.Clean();
+
+        //
+        result = isSupplyZoneBreaked ||
+                 isDemandZoneBreaked;
+
+        //
+        return result;
+    }
+
     //
     bool IsOrderFlowBreaked(
         int &breakedIndex,