/// <summary>
/// Replace the the variable name with the requested expression.
/// </summary>
/// <param name="varName"></param>
/// <param name="replacementExpr"></param>
/// <returns></returns>
public IVariableScopeHolder AddInternal(string varName, Expression replacementExpr)
{
Debug.WriteLine("Cache Expression: {0} => {1}", varName, replacementExpr);
///
/// Somethign to get us back to this state
///
IVariableScopeHolder popper = null;
if (_expressionReplacement.ContainsKey(varName))
{
popper = new CCReplacementExpression(this, varName, _expressionReplacement[varName]);
}
else
{
popper = new CCReplacementExpression(this, varName, null);
}
///
/// And save the expression for future lookup
///
if (replacementExpr != null)
{
_expressionReplacement[varName] = replacementExpr;
}
else
{
_expressionReplacement.Remove(varName);
}
return(popper);
}
/// <summary>
/// Given an expression which we can turn into a loop, add the loop to the current
/// code block.
/// </summary>
/// <param name="loopExpr"></param>
/// <param name="indexName"></param>
private void CodeLoopOverExpression(IQuerySource query, Expression loopExpr, string indexName)
{
MainIndexScope = Expressions.ArrayExpressionParser.ParseArrayExpression(query, loopExpr, _codeEnv, _codeContext, MEFContainer);
if (MainIndexScope == null)
{
MainIndexScope = _codeContext.Add(query, _codeContext.LoopVariable);
}
Debug.WriteLine("CodeLoopOverExpression: LoopExpr: {0} LoopVar: {1}", loopExpr.ToString(), _codeContext.LoopVariable.ToString());
}
/// <summary>
/// Add a variable that should be eliminated.
/// </summary>
/// <param name="variableScopeHolder"></param>
public void CacheVariableToEliminate(IVariableScopeHolder variableScopeHolder)
{
if (variableScopeHolder == null)
{
throw new ArgumentNullException("variableScopeHolder");
}
_cachedScopeVars.Add(variableScopeHolder);
}
/// <summary>
/// Replace or add the variable as requested.
/// </summary>
/// <param name="varName"></param>
/// <param name="replacementExpr"></param>
/// <returns></returns>
public IVariableScopeHolder AddInternal(IQuerySource query, Expression replacementExpr)
{
Debug.WriteLine("Caching QS {0} => {1}", query.ToString(), replacementExpr.ToString());
// If this QS is referenced by a QM cache line, then we need to invalidate that QM.
if (_queryReplacement.ContainsKey(query))
{
var badQM = (from q in _queryModelCache
where q.Value._referencedQS.Contains(query)
select q.Key).ToArray();
Debug.Indent();
foreach (var qm in badQM)
{
Debug.WriteLine("Removing QM due to change in QS {0}{1}", qm.ToString(), "");
_queryModelCache.Remove(qm);
}
Debug.Unindent();
}
///
/// Somethign to get us back to this state
///
IVariableScopeHolder popper = null;
if (_queryReplacement.ContainsKey(query))
{
popper = new CCReplacementQuery(this, query, _queryReplacement[query]);
}
else
{
popper = new CCReplacementQuery(this, query, null);
}
///
/// And save the expression for future lookup
///
if (replacementExpr != null)
{
_queryReplacement[query] = replacementExpr;
}
else
{
_queryReplacement.Remove(query);
}
return(popper);
}
/// <summary>
/// Run the main from clause in a query. This can be called more than once - when you have
/// multiple from queries at the top level.
/// </summary>
/// <param name="fromClause"></param>
/// <param name="queryModel"></param>
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
// If the fromClause is a complex expression, then we will have to parse it out.
// If it is just the value type for the TTree we are looping over, then we have to
// do something slightly different.
if (fromClause.ItemType == _codeContext.BaseNtupleObjectType && (fromClause.FromExpression is ConstantExpression))
{
MainIndexScope = new OutterLoopArrayInfo(fromClause.ItemType).CodeLoopOverArrayInfo(fromClause, _codeEnv, _codeContext, MEFContainer);
}
else
{
CodeLoopOverExpression(fromClause, fromClause.FromExpression, fromClause.ItemName);
}
}
/// <summary>
/// Add a variable that should be eliminated.
/// </summary>
/// <param name="variableScopeHolder"></param>
public void CacheVariableToEliminate(IVariableScopeHolder variableScopeHolder)
{
if (variableScopeHolder == null)
throw new ArgumentNullException("variableScopeHolder");
_cachedScopeVars.Add(variableScopeHolder);
}
/// <summary>
/// Given an expression which we can turn into a loop, add the loop to the current
/// code block.
/// </summary>
/// <param name="loopExpr"></param>
/// <param name="indexName"></param>
private void CodeLoopOverExpression(IQuerySource query, Expression loopExpr, string indexName)
{
MainIndexScope = Expressions.ArrayExpressionParser.ParseArrayExpression(query, loopExpr, _codeEnv, _codeContext, MEFContainer);
if (MainIndexScope == null)
MainIndexScope = _codeContext.Add(query, _codeContext.LoopVariable);
Debug.WriteLine("CodeLoopOverExpression: LoopExpr: {0} LoopVar: {1}", loopExpr.ToString(), _codeContext.LoopVariable.ToString());
}
/// <summary>
/// Run the main from clause in a query. This can be called more than once - when you have
/// multiple from queries at the top level.
/// </summary>
/// <param name="fromClause"></param>
/// <param name="queryModel"></param>
public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
{
// If the fromClause is a complex expression, then we will have to parse it out.
// If it is just the value type for the TTree we are looping over, then we have to
// do something slightly different.
if (fromClause.ItemType == _codeContext.BaseNtupleObjectType && (fromClause.FromExpression is ConstantExpression))
{
MainIndexScope = new OutterLoopArrayInfo(fromClause.ItemType).CodeLoopOverArrayInfo(fromClause, _codeEnv, _codeContext, MEFContainer);
}
else
{
CodeLoopOverExpression(fromClause, fromClause.FromExpression, fromClause.ItemName);
}
}
