/// <summary>
/// We want to print the results out to a file.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
/// <remarks>
/// We can handle several types of streams here:
/// 1) a stream of double's - this is just one column.
/// 2) A stream of Tuples
/// 3) A stream of custom objects
/// </remarks>
public override Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
// Argument checking
var asTTree = resultOperator as AsTTreeResultOperator;
if (asTTree == null)
{
throw new ArgumentException("resultOperaton");
}
// Declare the includes.
gc.AddIncludeFile("<map>");
gc.AddIncludeFile("TSystem.h");
gc.AddIncludeFile("TFile.h");
gc.AddIncludeFile("TTree.h");
// If we were left to our own devices generating an output file, then make one up based on the tree name.
var outputFile = asTTree.OutputFile != null
? asTTree.OutputFile
: new FileInfo($"{asTTree.TreeName}.root");
// Generate a real filename. We are going to key the file by the cache key. Unfortunately, at this
// point in the generation the cache key isn't known. So we have to have a 'promise' that can be used
// for later when the code is actually generated.
var outputFilePromise = GenerateUniqueFile(outputFile, cc);
// Declare the TTree and the file we will be using!
// Initialization is not important as we will over-write this directly.
var stream = DeclarableParameter.CreateDeclarableParameterExpression(typeof(OutputTTreeFileType));
stream.InitialValue = new OutputTTreeFileType(outputFilePromise);
// Open the file and declare the tree
gc.AddInitalizationStatement(new StatementSimpleStatement(() => $"{stream.RawValue}.first = new TFile(\"<><>{outputFilePromise().FullName.AddCPPEscapeCharacters()}<><>\",\"RECREATE\")", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
gc.AddInitalizationStatement(new StatementSimpleStatement($"{stream.RawValue}.second = new TTree(\"{asTTree.TreeName}\", \"{asTTree.TreeTitle}\")", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
// Get the list of item values we are going to need here.
List <Expression> itemValues = ExtractItemValueExpressions(queryModel);
// We are just going to print out the line with the item in it.
var itemAsValues = itemValues.Select(iv => ExpressionToCPP.GetExpression(iv, gc, cc, container)).ToArray();
var pstatement = new StatementFillTree(stream, itemAsValues.Zip(asTTree.HeaderColumns, (i, h) => Tuple.Create(i, h)).ToArray());
gc.Add(pstatement);
// The return is a file path in the C# world. But here in C++, what should be returned?
// We will use a string.
return(stream);
}
/// <summary>
/// We want to print the results out to a file.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
/// <remarks>
/// We can handle several types of streams here:
/// 1) a stream of double's - this is just one column.
/// 2) A stream of Tuples
/// 3) A stream of custom objects
/// </remarks>
public override Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
// Argument checking
var asCSV = resultOperator as AsCSVResultOperator;
if (asCSV == null)
{
throw new ArgumentException("resultOperaton");
}
// Declare the includes.
gc.AddIncludeFile("<fstream>");
gc.AddIncludeFile("<iostream>");
// The output filename. How we do this is a little funny because we need the hash from the completely
// done query, which isn't ready just yet.
var outputFile = GenerateUniqueFile(asCSV.OutputFile, cc);
var stream = DeclarableParameter.CreateDeclarableParameterExpression(typeof(OutputCSVTextFileType));
stream.InitialValue = new OutputCSVTextFileType(outputFile);
var headerline = new StringBuilder();
bool first = true;
foreach (var h in asCSV.HeaderColumns)
{
if (!first)
{
headerline.Append(",");
}
headerline.Append(h);
first = false;
}
gc.AddInitalizationStatement(new Statements.StatementSimpleStatement($"{stream.RawValue} << \"{headerline.ToString()}\" << std::endl;", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
// Get the list of item values we are going to need here.
List <Expression> itemValues = ExtractItemValueExpressions(queryModel);
// We are just going to print out the line with the item in it.
var itemAsValues = itemValues.Select(iv => ExpressionToCPP.GetExpression(iv, gc, cc, container));
var pstatement = new StatementCSVDump(stream, itemAsValues.ToArray());
gc.Add(pstatement);
// The return is a file path in the C# world. But here in C++, what should be returned?
// We will use a string.
return(stream);
}
/// <summary>
/// We want to print the results out to a file.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
/// <remarks>
/// We can handle several types of streams here:
/// 1) a stream of double's - this is just one column.
/// 2) A stream of Tuples
/// 3) A stream of custom objects
/// </remarks>
public override Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
// Argument checking
var asTTree = resultOperator as AsTTreeResultOperator;
if (asTTree == null)
throw new ArgumentException("resultOperaton");
// Declare the includes.
gc.AddIncludeFile("<map>");
gc.AddIncludeFile("TSystem.h");
gc.AddIncludeFile("TFile.h");
gc.AddIncludeFile("TTree.h");
// If we were left to our own devices generating an output file, then make one up based on the tree name.
var outputFile = asTTree.OutputFile != null
? asTTree.OutputFile
: new FileInfo($"{asTTree.TreeName}.root");
// Declare the TTree and the file we will be using!
// Initialization is not important as we will over-write this directly.
var stream = DeclarableParameter.CreateDeclarableParameterExpression(typeof(OutputTTreeFileType));
stream.InitialValue = new OutputTTreeFileType(outputFile);
// Generate a real filename. We are going to key the file by the cache key. Unfortunately, at this
// point in the generation the cache key isn't known. So we have to have a 'promise' that can be used
// for later when the code is actually generated.
var outputFilePromise = GenerateUniqueFile(outputFile, cc);
// Open the file and declare the tree
gc.AddInitalizationStatement(new StatementSimpleStatement(() => $"{stream.RawValue}.first = new TFile(\"{outputFilePromise().FullName.AddCPPEscapeCharacters()}\",\"RECREATE\")", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
gc.AddInitalizationStatement(new StatementSimpleStatement($"{stream.RawValue}.second = new TTree(\"{asTTree.TreeName}\", \"{asTTree.TreeTitle}\")", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
// Get the list of item values we are going to need here.
List<Expression> itemValues = ExtractItemValueExpressions(queryModel);
// We are just going to print out the line with the item in it.
var itemAsValues = itemValues.Select(iv => ExpressionToCPP.GetExpression(iv, gc, cc, container)).ToArray();
var pstatement = new StatementFillTree(stream, itemAsValues.Zip(asTTree.HeaderColumns, (i, h) => Tuple.Create(i, h)).ToArray());
gc.Add(pstatement);
// The return is a file path in the C# world. But here in C++, what should be returned?
// We will use a string.
return stream;
}
/// <summary>
/// We want to print the results out to a file.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="_codeEnv"></param>
/// <param name="_codeContext"></param>
/// <param name="container"></param>
/// <returns></returns>
/// <remarks>
/// We can handle several types of streams here:
/// 1) a stream of double's - this is just one column.
/// 2) A stream of Tuples
/// 3) A stream of custom objects
/// </remarks>
public override Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
// Argument checking
var asCSV = resultOperator as AsCSVResultOperator;
if (asCSV == null)
throw new ArgumentException("resultOperaton");
// Declare the includes.
gc.AddIncludeFile("<fstream>");
gc.AddIncludeFile("<iostream>");
// The output filename. How we do this is a little funny because we need the hash from the completely
// done query, which isn't ready just yet.
var outputFile = GenerateUniqueFile(asCSV.OutputFile, cc);
var stream = DeclarableParameter.CreateDeclarableParameterExpression(typeof(OutputCSVTextFileType));
stream.InitialValue = new OutputCSVTextFileType(outputFile);
var headerline = new StringBuilder();
bool first = true;
foreach (var h in asCSV.HeaderColumns)
{
if (!first)
{
headerline.Append(", ");
}
headerline.Append(h);
first = false;
}
gc.AddInitalizationStatement(new Statements.StatementSimpleStatement($"{stream.RawValue} << \"{headerline.ToString()}\" << std::endl;", dependentVars: new string[0], resultVars: new string[] { stream.RawValue }));
// Get the list of item values we are going to need here.
List<Expression> itemValues = ExtractItemValueExpressions(queryModel);
// We are just going to print out the line with the item in it.
var itemAsValues = itemValues.Select(iv => ExpressionToCPP.GetExpression(iv, gc, cc, container));
var pstatement = new StatementCSVDump(stream, itemAsValues.ToArray());
gc.Add(pstatement);
// The return is a file path in the C# world. But here in C++, what should be returned?
// We will use a string.
return stream;
}
/// <summary>
/// New a ROOT object. Make sure that it gets dtor'd!
/// </summary>
/// <param name="expression"></param>
/// <param name="result"></param>
/// <param name="gc"></param>
/// <param name="context"></param>
/// <param name="container"></param>
/// <returns></returns>
public Expression ProcessNew(NewExpression expression, out IValue result, IGeneratedQueryCode gc, CompositionContainer container)
{
///
/// Do checks
///
if (gc == null)
{
throw new ArgumentException("gc");
}
if (expression == null)
{
throw new ArgumentNullException("expression");
}
///
/// Figure out the type. We can only get here if we get through ROOTNET.xxx
///
result = null;
string tname = expression.Type.FullName.Substring(8);
if (tname[0] != 'N')
{
throw new ArgumentException(string.Format("Don't know how to translate to a ROOT type '{0}'", expression.Type.FullName));
}
tname = tname.Substring(1);
///
/// We assume the include file "just works" - this is ROOT, after all. But lets hope.
/// This is something we might have to deal with later. :-)
///
gc.AddIncludeFile(string.Format("{0}.h", tname));
///
/// Now, build the constructor, and add it to the statement list.
///
var ctor = new StringBuilder();
var ctorName = expression.Type.CreateUniqueVariableName();
ctor.AppendFormat("{0} {1}", tname, ctorName);
var argDep = AddMethodArguments(expression.Arguments, gc, container, ctor).ToArray();
gc.Add(new Statements.StatementSimpleStatement(ctor.ToString(), dependentVars: argDep.Select(i => i.RawValue).ToArray(), resultVars: new string[] { ctorName }));
///
/// Now, everything in the C++ translation is a pointer, so we will
/// not create a pointer to this guy.
///
var ptrDecl = new StringBuilder();
var ptrName = expression.Type.CreateUniqueVariableName();
ptrDecl.AppendFormat("{0} *{1} = &{2}", tname, ptrName, ctorName);
gc.Add(new Statements.StatementSimpleStatement(ptrDecl.ToString(), dependentVars: new string[] { ctorName }, resultVars: new string[] { ptrName }));
///
/// That pointer is what we return for later use!
///
result = new ValSimple(ptrName, expression.Type, argDep);
return(expression);
}
/// <summary>
/// Translate the method call
/// </summary>
/// <param name="expr"></param>
/// <param name="result"></param>
/// <param name="gc"></param>
/// <param name="context"></param>
/// <returns></returns>
public IValue CodeMethodCall(MethodCallExpression expr, IGeneratedQueryCode gc, CompositionContainer container)
{
Init();
///
/// First see if we can't locate the method call that at least matches in names
///
var matchingMethodNames = from kt in _knownTypes
where kt.Name == expr.Method.DeclaringType.Name
from m in kt.Methods
where m.Name == expr.Method.Name
select new
{
theType = kt,
theMethod = m
};
///
/// Next, match with the arguments
///
var matchingMethod = from m in matchingMethodNames
where m.theMethod.Arguments.Length == expr.Arguments.Count
where m.theMethod.Arguments.Zip(expr.Arguments, (us, them) => new Tuple <KnownTypeInfo.MechodArg, Expression>(us, them)).All(apair => apair.Item1.Type == apair.Item2.Type.FullName)
select m;
///
/// Ok, at this point, we should have only one guy. If we have more then just choose the first
///
var method = matchingMethod.FirstOrDefault();
if (method == null)
{
throw new ArgumentException("Could not find a matching method to translate for the call " + expr.ToString());
}
///
/// And now translate the call
///
StringBuilder rawValue = new StringBuilder();
rawValue.Append(method.theMethod.CPPName);
rawValue.Append("(");
bool first = true;
var dependents = Enumerable.Empty <IDeclaredParameter>();
foreach (var arg in expr.Arguments.Zip(method.theMethod.Arguments, (m, a) => Tuple.Create(m, a)))
{
if (!first)
{
rawValue.Append(",");
}
first = false;
var e = ExpressionToCPP.InternalGetExpression(arg.Item1, gc, null, container);
rawValue.AppendFormat("({0}){1}", arg.Item2.CPPType, e.RawValue);
dependents = dependents.Concat(e.Dependants);
}
rawValue.Append(")");
var result = new ValSimple(rawValue.ToString(), expr.Type, dependents);
///
/// Include files
///
foreach (var ifile in method.theMethod.IncludeFiles)
{
gc.AddIncludeFile(ifile);
}
///
/// We aren't re-writing this expression, so just return it.
///
return(result);
}
/// <summary>
/// Build a code statement from the include files, the expression for the method call, and the generated lines of code.
/// </summary>
/// <param name="expr"></param>
/// <param name="gc"></param>
/// <param name="container"></param>
/// <param name="includeFiles"></param>
/// <param name="loc"></param>
/// <returns></returns>
public static IValue BuildCPPCodeStatement(MethodCallExpression expr, IGeneratedQueryCode gc, CompositionContainer container, string[] includeFiles, string[] loc)
{
// Get include files in.
if (includeFiles != null)
{
foreach (var inc in includeFiles)
{
gc.AddIncludeFile(inc);
}
}
// Next, go after the lines of code. We have to first sort out what parameter names we are looking at,
// and then force a translation of those parameters into simple values we can pass to the C++ code we
// are going to pull back.
var paramsTranslated = from p in expr.Arguments.Zip(expr.Method.GetParameters(), (arg, param) => Tuple.Create(arg, param))
select new
{
Name = p.Item2.Name,
Translated = ExpressionToCPP.InternalGetExpression(p.Item1, gc, null, container)
};
var paramLookup = paramsTranslated.ToDictionary(v => v.Name, v => v.Translated.ApplyParensIfNeeded());
// Parse out the list of variables that are used. We will be passing these up the line as needed
// so that we can tell how to optimize things.
var dependents = new HashSet <string>(FindDeclarableParameters.FindAll(expr).Select(e => e.RawValue));
// We also need a return variable. Since this can be multiple lines of code and we don't
// know how the result will be used, we have to declare it up front... and pray they
// use it correctly! :-)
var cppResult = DeclarableParameter.CreateDeclarableParameterExpression(expr.Type);
var cppStatement = new CPPCodeStatement(expr.Method, cppResult, loc, dependents);
gc.Add(cppStatement);
gc.Add(cppResult);
paramLookup.Add(expr.Method.Name, cppResult.RawValue);
var result = new ValSimple(cppResult.RawValue, expr.Type, DeclarableParameter.CreateDeclarableParameterExpression(cppResult.RawValue, expr.Type).AsArray());
// Make sure a result exists in here! This at least will prevent some bad C++ code from getting generated!
var lookForResult = new Regex(string.Format(@"\b{0}\b", expr.Method.Name));
bool didReference = loc.Any(l => lookForResult.Match(l).Success);
if (!didReference)
{
throw new ArgumentException(string.Format("The C++ code attached to the method '{0}' doesn't seem to set a result.", expr.Method.Name));
}
// Figure out if there are any Unique variables. If there are, then we need to do
// a replacement on them.
var findUnique = new Regex(@"\b\w*Unique\b");
var varUniqueRequests = (from l in loc
let matches = findUnique.Matches(l)
from m in Enumerable.Range(0, matches.Count)
select matches[m].Value).Distinct();
foreach (var varRepl in varUniqueRequests)
{
var uniqueName = varRepl.Substring(0, varRepl.Length - "Unique".Length);
var uniqueTranslated = uniqueName + _uniqueCounter.ToString();
cppStatement.AddUniqueVariable(varRepl, uniqueTranslated);
_uniqueCounter++;
}
// Add the parameters that need to be translated here.
foreach (var paramName in paramLookup)
{
cppStatement.AddParamReplacement(paramName.Key, paramName.Value);
}
return(result);
}
/// <summary>
/// Build a code statement from the include files, the expression for the method call, and the generated lines of code.
/// </summary>
/// <param name="expr"></param>
/// <param name="gc"></param>
/// <param name="container"></param>
/// <param name="includeFiles"></param>
/// <param name="loc"></param>
/// <returns></returns>
public static IValue BuildCPPCodeStatement(MethodCallExpression expr, IGeneratedQueryCode gc, CompositionContainer container, string[] includeFiles, string[] loc)
{
// Get include files in.
if (includeFiles != null)
{
foreach (var inc in includeFiles)
{
gc.AddIncludeFile(inc);
}
}
// Next, go after the lines of code. We have to first sort out what parameter names we are looking at,
// and then force a translation of those parameters into simple values we can pass to the C++ code we
// are going to pull back.
var paramsTranslated = from p in expr.Arguments.Zip(expr.Method.GetParameters(), (arg, param) => Tuple.Create(arg, param))
select new
{
Name = p.Item2.Name,
Translated = ExpressionToCPP.InternalGetExpression(p.Item1, gc, null, container)
};
var paramLookup = paramsTranslated.ToDictionary(v => v.Name, v => v.Translated.ApplyParensIfNeeded());
// Parse out the list of variables that are used. We will be passing these up the line as needed
// so that we can tell how to optimize things.
var dependents = new HashSet<string>(FindDeclarableParameters.FindAll(expr).Select(e => e.RawValue));
// We also need a return variable. Since this can be multiple lines of code and we don't
// know how the result will be used, we have to declare it up front... and pray they
// use it correctly! :-)
var cppResult = DeclarableParameter.CreateDeclarableParameterExpression(expr.Type);
var cppStatement = new CPPCodeStatement(expr.Method, cppResult, loc, dependents);
gc.Add(cppStatement);
gc.Add(cppResult);
paramLookup.Add(expr.Method.Name, cppResult.RawValue);
var result = new ValSimple(cppResult.RawValue, expr.Type, DeclarableParameter.CreateDeclarableParameterExpression(cppResult.RawValue, expr.Type).AsArray());
// Make sure a result exists in here! This at least will prevent some bad C++ code from getting generated!
var lookForResult = new Regex(string.Format(@"\b{0}\b", expr.Method.Name));
bool didReference = loc.Any(l => lookForResult.Match(l).Success);
if (!didReference)
throw new ArgumentException(string.Format("The C++ code attached to the method '{0}' doesn't seem to set a result.", expr.Method.Name));
// Figure out if there are any Unique variables. If there are, then we need to do
// a replacement on them.
var findUnique = new Regex(@"\b\w*Unique\b");
var varUniqueRequests = (from l in loc
let matches = findUnique.Matches(l)
from m in Enumerable.Range(0, matches.Count)
select matches[m].Value).Distinct();
foreach (var varRepl in varUniqueRequests)
{
var uniqueName = varRepl.Substring(0, varRepl.Length - "Unique".Length);
var uniqueTranslated = uniqueName + _uniqueCounter.ToString();
cppStatement.AddUniqueVariable(varRepl, uniqueTranslated);
_uniqueCounter++;
}
// Add the parameters that need to be translated here.
foreach (var paramName in paramLookup)
{
cppStatement.AddParamReplacement(paramName.Key, paramName.Value);
}
return result;
}
/// <summary>
/// Translate the method call
/// </summary>
/// <param name="expr"></param>
/// <param name="result"></param>
/// <param name="gc"></param>
/// <param name="context"></param>
/// <returns></returns>
public IValue CodeMethodCall(MethodCallExpression expr, IGeneratedQueryCode gc, CompositionContainer container)
{
Init();
///
/// First see if we can't locate the method call that at least matches in names
///
var matchingMethodNames = from kt in _knownTypes
where kt.Name == expr.Method.DeclaringType.Name
from m in kt.Methods
where m.Name == expr.Method.Name
select new
{
theType = kt,
theMethod = m
};
///
/// Next, match with the arguments
///
var matchingMethod = from m in matchingMethodNames
where m.theMethod.Arguments.Length == expr.Arguments.Count
where m.theMethod.Arguments.Zip(expr.Arguments, (us, them) => new Tuple<KnownTypeInfo.MechodArg, Expression>(us, them)).All(apair => apair.Item1.Type == apair.Item2.Type.FullName)
select m;
///
/// Ok, at this point, we should have only one guy. If we have more then just choose the first
///
var method = matchingMethod.FirstOrDefault();
if (method == null)
throw new ArgumentException("Could not find a matching method to translate for the call " + expr.ToString());
///
/// And now translate the call
///
StringBuilder rawValue = new StringBuilder();
rawValue.Append(method.theMethod.CPPName);
rawValue.Append("(");
bool first = true;
var dependents = Enumerable.Empty<IDeclaredParameter>();
foreach (var arg in expr.Arguments.Zip(method.theMethod.Arguments, (m, a) => Tuple.Create(m, a)))
{
if (!first)
rawValue.Append(",");
first = false;
var e = ExpressionToCPP.InternalGetExpression(arg.Item1, gc, null, container);
rawValue.AppendFormat("({0}){1}", arg.Item2.CPPType, e.RawValue);
dependents = dependents.Concat(e.Dependants);
}
rawValue.Append(")");
var result = new ValSimple(rawValue.ToString(), expr.Type, dependents);
///
/// Include files
///
foreach (var ifile in method.theMethod.IncludeFiles)
{
gc.AddIncludeFile(ifile);
}
///
/// We aren't re-writing this expression, so just return it.
///
return result;
}