public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
env.CompileDeploy("create schema SomeType ()", path);
env.CompileDeploy(
"@Name('flow') create dataflow MyDataFlowOne MyOp -> outstream<SomeType> {propOne:'abc', propThree:'xyz'}",
path);
var options = new EPDataFlowInstantiationOptions();
var myParameterProvider = new MyParameterProvider(Collections.SingletonDataMap("propTwo", "def"));
options.WithParameterProvider(myParameterProvider);
env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "MyDataFlowOne", options);
var myOp = MyOp.GetAndClearInstances()[0];
Assert.AreEqual("abc", myOp.PropOne);
Assert.AreEqual("def", myOp.PropTwo);
Assert.AreEqual(3, myParameterProvider.contextMap.Count);
Assert.IsNotNull(myParameterProvider.contextMap.Get("propOne"));
var context = myParameterProvider.contextMap.Get("propTwo");
Assert.AreEqual("propTwo", context.ParameterName);
Assert.AreEqual("MyOp", context.OperatorName);
Assert.AreSame(myOp.Factory, context.Factory);
Assert.AreEqual(0, context.OperatorNum);
Assert.AreEqual("MyDataFlowOne", context.DataFlowName);
context = myParameterProvider.contextMap.Get("propThree");
Assert.AreEqual("propThree", context.ParameterName);
Assert.AreEqual("MyOp", context.OperatorName);
Assert.AreSame(myOp.Factory, context.Factory);
Assert.AreEqual(0, context.OperatorNum);
env.UndeployAll();
}
public double Evaluate()
{
if (MyOp == null)
{
return(Value);
}
return(MyOp.Evaluate(ChildNodes));
}
public void Calculate(MyOp oper)
{
Console.WriteLine("Calculator...");
// Calculate
int res = oper(4, 5);
Console.WriteLine(res);
// Show Result
}
public void AddParent()
{
var op1 = new MyOp();
var op2 = new MyOp();
op1.AddParent(op2);
Assert.IsTrue(op1.Parents.Contains(op2));
Assert.IsTrue(op2.Children.Contains(op1));
}
public void AddParent()
{
var cns = new ConvNetSharp <float>();
var op1 = new MyOp(cns);
var op2 = new MyOp(cns);
op1.AddParent(op2);
Assert.IsTrue(op1.Parents.Contains(op2));
Assert.IsTrue(op2.Children.Contains(op1));
}
public void RemoveParent()
{
var op1 = new MyOp();
var op2 = new MyOp();
op1.AddParent(op2);
op1.RemoveParent(op2);
Assert.IsFalse(op1.Parents.Contains(op2));
Assert.IsFalse(op2.Children.Contains(op1));
}
// Query using a custom group operation:
private IDataList QueryBigOrders()
{
// get OrderDetails table
dynamic od = workspace.table(Utils.OrderDetails.Name);
// aggregate OrderDetails table
dynamic qp = workspace.query("query_bigOrders", new
{
Product = od.ProductID, // group by order
BigOrders = MyOp.BigOrders(od.ProductID, od.Quantity) // how many big orders are made for each product
});
return(qp.Query.Execute());
}
public void ContextSwitchOperator_Monitoring()
{
var vals = new List <int>();
var obv = Observer.Create <int>(vals.Add, _ => { }, () => { });
var myOp = new MyOp <int>(obv);
using var ps = PhysicalScheduler.Create();
using var ls = new LogicalScheduler(ps);
ls.PauseAsync().Wait();
var opCtx = new Context
{
InstanceId = new Uri("test://sub"),
Scheduler = ls,
};
new SubscriptionInitializeVisitor(myOp).Initialize(opCtx);
var msgs = new List <int> {
4, 3, 2, 1
};
var enqueueCount = 0;
myOp.MonitorableQueue.Enqueueing += msg =>
{
Assert.AreEqual(msg, msgs[enqueueCount++]);
};
var countdown = new CountdownEvent(msgs.Count);
var dequeueCount = 0;
myOp.MonitorableQueue.Dequeued += msg =>
{
Assert.AreEqual(msg, msgs[dequeueCount++]);
countdown.Signal();
};
foreach (var msg in msgs)
{
myOp.OnNext(msg);
}
Assert.AreEqual(msgs.Count, myOp.MonitorableQueue.QueueSize);
ls.Continue();
countdown.Wait();
}
// Query using a custom operation:
// custom discount information for all products
private IDataList QueryProductCustomDiscount()
{
// get OrderDetails table
dynamic od = workspace.table(Utils.OrderDetails.Name);
// aggregate OrderDetails table
dynamic qp = workspace.query("query_productCustomDiscount", new
{
ds = MyOp.ProgressiveDiscount(od.UnitPrice, od.Discount, od.Quantity), // calculate discount for a product in an order
Product = od.ProductID, // group by product
OrderCount = Op.Count(od.OrderID), // order count for a product
DiscountSum = Op.Sum("ds") // total progressive discount for a product in all orders
});
return(qp.Query.Execute());
}
private void RunAssertionParameterInjectionCallback(EPServiceProvider epService)
{
epService.EPAdministrator.CreateEPL("create schema SomeType ()");
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne MyOp -> outstream<SomeType> {propOne:'abc', propThree:'xyz'}");
var myOp = new MyOp("myid");
var options = new EPDataFlowInstantiationOptions();
options.OperatorProvider(new DefaultSupportGraphOpProvider(myOp));
var myParameterProvider = new MyParameterProvider(Collections.SingletonDataMap("propTwo", "def"));
options.ParameterProvider(myParameterProvider);
Assert.AreEqual("myid", myOp.Id);
Assert.IsNull(myOp.PropOne);
Assert.IsNull(myOp.PropTwo);
epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options);
Assert.AreEqual("abc", myOp.PropOne);
Assert.AreEqual("def", myOp.PropTwo);
Assert.AreEqual(3, myParameterProvider.ContextMap.Count);
Assert.IsNotNull(myParameterProvider.ContextMap.Get("propOne"));
EPDataFlowOperatorParameterProviderContext context = myParameterProvider.ContextMap.Get("propTwo");
Assert.AreEqual("propTwo", context.ParameterName);
Assert.AreEqual("MyOp", context.OperatorName);
Assert.AreSame(myOp, context.OperatorInstance);
Assert.AreEqual(0, context.OperatorNum);
Assert.AreEqual(null, context.ProvidedValue);
Assert.AreEqual("MyDataFlowOne", context.DataFlowName);
context = myParameterProvider.ContextMap.Get("propThree");
Assert.AreEqual("propThree", context.ParameterName);
Assert.AreEqual("MyOp", context.OperatorName);
Assert.AreSame(myOp, context.OperatorInstance);
Assert.AreEqual(0, context.OperatorNum);
Assert.AreEqual("xyz", context.ProvidedValue);
epService.EPAdministrator.DestroyAllStatements();
}
static void Main(string[] args)
{
OpSet set = new OpSet();
MyOp op1 = set.Add;
//op1 = op1 + set.Subtract + set.Add - set.Subtract;
op1 += set.Subtract;
op1 += set.Add;
op1 -= set.Subtract;
foreach (var fun in op1.GetInvocationList())
{
Console.WriteLine(fun.Method.Name);
}
int res = op1(3, 4);
Console.WriteLine(res);
return;
Calculator math = new Calculator();
//math.Calculate(Add);
math.Calculate(set.Add);
int age = 10;
MyOp var1 = Rubbish;
MyOp[] ops = new MyOp[3];
int result = var1(3, 4);
Console.WriteLine(result);
}
