/// <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); } }