Demonstrates the basic LIFO (Last-In, First-Out) behavior of NextOverload with two simple rules.

ID: 954

See: NextOverload 
				
					using uCalcSoftware;

var uc = new uCalc();
var t = new uCalc.Transformer();
t.Text = "This is a test.";

// Rule 1 (defined first, lower priority)
var rule1 = t.FromTo("is", "[IS_1]");

// Rule 2 (defined second, higher priority)
var rule2 = t.FromTo("is", "[IS_2]");

Console.WriteLine("--- Applying transform (Rule 2 has precedence) ---");
Console.WriteLine(t.Transform());
Console.WriteLine("");

Console.WriteLine("--- Using NextOverload ---");
// Get the rule that comes after rule2
var nextRule = rule2.NextOverload();

Console.WriteLine($"Rule 2 pattern: {rule2.Pattern}");
Console.WriteLine($"Next rule's pattern: {nextRule.Pattern}");

// Verify that the next rule is indeed rule1
Console.WriteLine($"Next rule is rule1: {nextRule.Handle() == rule1.Handle()}");
				
			
--- Applying transform (Rule 2 has precedence) ---
This [IS_2] a test.

--- Using NextOverload ---
Rule 2 pattern: is
Next rule's pattern: is
Next rule is rule1: True
Explore 600+ other examples
				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

#define tf(IsTrue) ((IsTrue) ? "True" : "False")

int main() {
   uCalc uc;
   uCalc::Transformer t;
   t.Text("This is a test.");

   // Rule 1 (defined first, lower priority)
   auto rule1 = t.FromTo("is", "[IS_1]");

   // Rule 2 (defined second, higher priority)
   auto rule2 = t.FromTo("is", "[IS_2]");

   cout << "--- Applying transform (Rule 2 has precedence) ---" << endl;
   cout << t.Transform() << endl;
   cout << "" << endl;

   cout << "--- Using NextOverload ---" << endl;
   // Get the rule that comes after rule2
   auto nextRule = rule2.NextOverload();

   cout << "Rule 2 pattern: " << rule2.Pattern() << endl;
   cout << "Next rule's pattern: " << nextRule.Pattern() << endl;

   // Verify that the next rule is indeed rule1
   cout << "Next rule is rule1: " << tf(nextRule.Handle() == rule1.Handle()) << endl;
}
				
			
--- Applying transform (Rule 2 has precedence) ---
This [IS_2] a test.

--- Using NextOverload ---
Rule 2 pattern: is
Next rule's pattern: is
Next rule is rule1: True
Explore 600+ other examples
				
					Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      t.Text = "This is a test."
      
      '// Rule 1 (defined first, lower priority)
      Dim rule1 = t.FromTo("is", "[IS_1]")
      
      '// Rule 2 (defined second, higher priority)
      Dim rule2 = t.FromTo("is", "[IS_2]")
      
      Console.WriteLine("--- Applying transform (Rule 2 has precedence) ---")
      Console.WriteLine(t.Transform())
      Console.WriteLine("")
      
      Console.WriteLine("--- Using NextOverload ---")
      '// Get the rule that comes after rule2
      Dim nextRule = rule2.NextOverload()
      
      Console.WriteLine($"Rule 2 pattern: {rule2.Pattern}")
      Console.WriteLine($"Next rule's pattern: {nextRule.Pattern}")
      
      '// Verify that the next rule is indeed rule1
      Console.WriteLine($"Next rule is rule1: {nextRule.Handle() = rule1.Handle()}")
   End Sub
End Module
				
			
--- Applying transform (Rule 2 has precedence) ---
This [IS_2] a test.

--- Using NextOverload ---
Rule 2 pattern: is
Next rule's pattern: is
Next rule is rule1: True
Explore 600+ other examples