public void TestSimpleRename()
{
var array = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var st = new StatementPairLoop(array, index1, index2);
var vr = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vr.RenameRawValue(vr.RawValue, index1.RawValue);
st.Add(new StatementAssign(vr, new ValSimple("ops", typeof(int))));
st.RenameVariable(index1.RawValue, "dude1");
Assert.AreEqual("dude1", index1.RawValue, "index1 after index1 rename");
Assert.AreEqual("dude1", (st.Statements.First() as StatementAssign).ResultVariable.RawValue, "sub statement not renamed correctly");
st.RenameVariable(index2.RawValue, "dude2");
Assert.AreEqual("dude1", index1.RawValue, "index1 after index2 rename");
Assert.AreEqual("dude2", index2.RawValue, "index1 after index1 rename");
st.RenameVariable(array.RawValue, "fork");
Assert.AreEqual("fork", array.RawValue, "array after array rename");
Assert.AreEqual("dude1", index1.RawValue, "index1 after array rename");
Assert.AreEqual("dude2", index2.RawValue, "index1 after array rename");
}
public void TestCombineWithSameArray()
{
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var arrayRecord = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var stp1 = new StatementPairLoop(arrayRecord, index1, index2);
var index3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var stp2 = new StatementPairLoop(arrayRecord, index3, index4);
var statAss = new StatementAssign(index3, new ValSimple("dude", typeof(int)), null);
stp2.Add(statAss);
var opt = new Factories.CodeOptimizerTest(true);
Assert.IsTrue(stp1.TryCombineStatement(stp2, opt), "Combine should have been ok");
Assert.AreEqual(1, stp1.Statements.Count(), "Improper number of combined sub-statements");
var s1 = stp1.Statements.First();
Assert.IsInstanceOfType(s1, typeof(StatementAssign), "Statement is not right type");
var sa = s1 as StatementAssign;
Assert.AreEqual(index1.RawValue, sa.ResultVariable.RawValue, "rename of variables didn't occur correctly");
}
/// <summary>
/// Take the incoming stream of items, and send them along! :-)
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
public void ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
//
// Some basic checks on the input.
//
if (cc == null)
{
throw new ArgumentNullException("cc");
}
if (gc == null)
{
throw new ArgumentNullException("gc");
}
if (cc.LoopVariable == null)
{
throw new ArgumentNullException("No defined loop variable!");
}
//
// Get the indexer that is being used to access things. We will just push that onto a temp vector of int's. That will be
// a list of the items that we want to come back and look at. That said, once done we need to pop-up one level in our
// depth.
//
var arrayRecord = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
gc.AddOutsideLoop(arrayRecord);
var recordIndexStatement = new Statements.StatementRecordIndicies(ExpressionToCPP.GetExpression(cc.LoopIndexVariable.AsExpression(), gc, cc, container), arrayRecord);
gc.Add(recordIndexStatement);
gc.Pop();
//
// Now, we go down one loop and run over the pairs with a special loop.
//
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var indexIterator = new Statements.StatementPairLoop(arrayRecord, index1, index2);
gc.Add(indexIterator);
//
// Finally, build the resulting loop variable. For now it is just a tuple, which is basically the formed expression we started with,
// but with the other index properties. Other bits will have to do the translation for us. :-)
//
var item1 = cc.LoopVariable.ReplaceSubExpression(cc.LoopIndexVariable.AsExpression(), index1);
var item2 = cc.LoopVariable.ReplaceSubExpression(cc.LoopIndexVariable.AsExpression(), index2);
var tupleType = typeof(Tuple <,>).MakeGenericType(cc.LoopVariable.Type, cc.LoopVariable.Type);
var newTuple = Expression.New(tupleType.GetConstructor(new Type[] { cc.LoopVariable.Type, cc.LoopVariable.Type }), item1, item2);
cc.SetLoopVariable(newTuple, null);
}
public void TestForEmittingNoStatements()
{
var array = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var t = new StatementPairLoop(array, index1, index2);
Assert.AreEqual(0, t.CodeItUp().Count(), "# of lines incorrect");
}
public void TestForEmittingSimpleStatement()
{
var array = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var t = new StatementPairLoop(array, index1, index2);
t.Add(new LINQToTTreeLib.Statements.StatementSimpleStatement("dir"));
Assert.AreEqual(9, t.CodeItUp().Count(), "# of lines incorrect");
}
public void TestCombineShouldFail()
{
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var arrayRecord = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var stp1 = new StatementPairLoop(arrayRecord, index1, index2);
var index3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var arrayRecord2 = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var stp2 = new StatementPairLoop(arrayRecord2, index3, index4);
Assert.IsFalse(stp1.TryCombineStatement(stp2, null), "should not have combined");
}
public void TestTryCombinedFail()
{
var indiciesToInspect = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var passedArray = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(bool));
var s1 = new StatementCheckLoopPairwise(indiciesToInspect, index1, index2, passedArray);
var indiciesToInspect1 = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var passedArray1 = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(bool));
var s2 = new StatementCheckLoopPairwise(indiciesToInspect1, index3, index4, passedArray1);
Assert.IsFalse(s1.TryCombineStatement(s2, null), "COmbine should fail");
}
public void TestTryCombineGood()
{
var indiciesToInspect = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var passedArray = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(bool));
var s1 = new StatementCheckLoopPairwise(indiciesToInspect, index1, index2, passedArray);
var index3 = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index4 = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var passedArray1 = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(bool));
var s2 = new StatementCheckLoopPairwise(indiciesToInspect, index3, index4, passedArray1);
s2.Add(new StatementSimpleStatement(string.Format("{0} = dude", index3.RawValue)));
var co = new DoRenames(s2);
Assert.IsTrue(s1.TryCombineStatement(s2, co), "COmbine should pass");
Assert.AreEqual(1, s1.Statements.Count(), "# of statements");
Assert.AreEqual(string.Format("{0} = dude", index1.RawValue), (s1.Statements.First() as StatementSimpleStatement).Line, "statement not translated");
}
public void TestRename()
{
var indiciesToInspect = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var passedArray = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(bool));
var s1 = new StatementCheckLoopPairwise(indiciesToInspect, index1, index2, passedArray);
s1.Add(new StatementSimpleStatement(string.Format("{0} = fork", index2.RawValue)));
s1.RenameVariable(indiciesToInspect.RawValue, "dude1");
Assert.AreEqual("dude1", indiciesToInspect.RawValue, "indices 1");
s1.RenameVariable(index1.RawValue, "dude2");
Assert.AreEqual(index1.RawValue, "dude2", "index1 didn't get set");
s1.RenameVariable(index2.RawValue, "dude3");
Assert.AreEqual(index2.RawValue, "dude3", "index2 didn't get set");
s1.RenameVariable(passedArray.RawValue, "dude4");
Assert.AreEqual(passedArray.RawValue, "dude4", "passed array didn't get set");
Assert.AreEqual("dude3 = fork", (s1.Statements.First() as StatementSimpleStatement).Line, "statement 1 didn't get translated");
}
/// <summary>
/// Add the code to do the pair-wise loop.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
public void ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
var ro = resultOperator as PairWiseAllResultOperator;
if (ro == null)
{
throw new ArgumentNullException("Result operator is not of PairWiseAll type");
}
//
// First, record all the good indicies for this array
//
var arrayRecord = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
gc.AddOutsideLoop(arrayRecord);
var recordIndexStatement = new StatementRecordIndicies(ExpressionToCPP.GetExpression(cc.LoopIndexVariable.AsExpression(), gc, cc, container), arrayRecord);
gc.Add(recordIndexStatement);
gc.Pop();
///
/// Next, we create a loop that will mark all the guys as "good" that
/// the pair-wise function. Hopefully the statement below will be efficient and
/// not double-try anything! The lambda we've been passed we have to evaluate - twice -
/// for each, and pass it as a "test" to the statement. It will be some horrendus expression
/// I suppose!
///
var passAll = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(bool));
gc.Add(passAll);
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index1Lookup = cc.LoopVariable.ReplaceSubExpression(cc.LoopIndexVariable.AsExpression(), index1); //Expression.ArrayIndex(array, index1);
var index2Lookup = cc.LoopVariable.ReplaceSubExpression(cc.LoopIndexVariable.AsExpression(), index2); //Expression.ArrayIndex(array, index2);
var callLambda = Expression.Invoke(ro.Test,
index1Lookup,
index2Lookup
);
var xcheck = new Statements.StatementCheckLoopPairwise(arrayRecord,
index1, index2, passAll);
gc.Add(xcheck);
var test = new Statements.StatementTestLoopPairwise(
passAll,
ExpressionToCPP.GetExpression(callLambda, gc, cc, container));
gc.Add(test);
gc.Pop();
//
// Ok, the result of that will be the array we have here is now filled with the
// "proper" stuff. That is - we have "true" in everthing that is good. So we will
// now just loop over that and apply the index as needed.
//
var goodIndex = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
gc.Add(goodIndex);
var loopOverGood = new Statements.StatementLoopOverGood(arrayRecord, passAll, goodIndex);
gc.Add(loopOverGood);
cc.SetLoopVariable(cc.LoopVariable.ReplaceSubExpression(cc.LoopIndexVariable.AsExpression(), goodIndex), goodIndex);
}
public void TestForNonROOTObject()
{
var v = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
Assert.IsFalse(CanHandle(new SaveVarObject(), v), "int array should be false");
}
