private void AddRunningValue(Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo runningValue, List <string> runningValuesInGroup, List <string> previousValuesInGroup, Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection)
{
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
bool flag = runningValue.AggregateType == Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Previous;
List <string> list = (!flag) ? runningValuesInGroup : previousValuesInGroup;
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregatesImpl.GetAggregateObj(runningValue.Name);
if (dataAggregateObj == null)
{
dataAggregateObj = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(runningValue, m_odpContext);
aggregatesImpl.Add(dataAggregateObj);
}
else if (flag && (runningValue.Scope == null || runningValue.IsScopedInEvaluationScope))
{
dataAggregateObj.Init();
}
if (runningValue.Scope != null)
{
if (groupCollection.TryGetValue(runningValue.Scope, out IReference <RuntimeGroupRootObj> value))
{
using (value.PinValue())
{
value.Value().AddScopedRunningValue(dataAggregateObj);
}
}
else
{
Global.Tracer.Assert(condition: false, "RV with runtime scope escalation");
}
}
if (!list.Contains(dataAggregateObj.Name))
{
list.Add(dataAggregateObj.Name);
}
}
internal void Set(string name, Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo aggregateDef, List <string> duplicateNames, Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult aggregateResult)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = GetAggregateObj(name);
if (aggregateObj == null)
{
try
{
if (m_lockAdd)
{
Monitor.Enter(m_collection);
}
aggregateObj = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(aggregateDef, aggregateResult);
m_collection.Add(name, aggregateObj);
PopulateDuplicateNames(name, duplicateNames);
}
finally
{
if (m_lockAdd)
{
Monitor.Exit(m_collection);
}
}
}
else
{
aggregateObj.Set(aggregateResult);
}
}
private void CreateAggregates(List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo> aggDefs)
{
if (aggDefs == null || 0 >= aggDefs.Count)
{
return;
}
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < aggDefs.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo dataAggregateInfo = aggDefs[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregatesImpl.GetAggregateObj(dataAggregateInfo.Name);
if (dataAggregateObj == null)
{
dataAggregateObj = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(dataAggregateInfo, m_odpContext);
aggregatesImpl.Add(dataAggregateObj);
}
if (Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Previous != dataAggregateInfo.AggregateType)
{
if (Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Aggregate == dataAggregateInfo.AggregateType)
{
RuntimeDataRegionObj.AddAggregate(ref m_customAggregates, dataAggregateObj);
}
else
{
RuntimeDataRegionObj.AddAggregate(ref m_nonCustomAggregates, dataAggregateObj);
}
}
}
}
private object GetAggregateValue(string key, Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj)
{
aggregateObj.UsedInExpression = true;
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult dataAggregateObjResult = aggregateObj.AggregateResult();
if (dataAggregateObjResult == null)
{
Global.Tracer.Assert(m_odpContext.IsTablixProcessingMode, "Missing aggregate result outside of tablix processing");
throw new ReportProcessingException_MissingAggregateDependency();
}
if (dataAggregateObjResult.HasCode)
{
if ((dataAggregateObjResult.FieldStatus == DataFieldStatus.None || dataAggregateObjResult.FieldStatus == DataFieldStatus.IsError) && dataAggregateObjResult.Code != 0)
{
ErrorContext.Register(dataAggregateObjResult.Code, dataAggregateObjResult.Severity, dataAggregateObjResult.Arguments);
}
else if (dataAggregateObjResult.FieldStatus == DataFieldStatus.UnSupportedDataType)
{
ErrorContext.Register(ProcessingErrorCode.rsAggregateOfInvalidExpressionDataType, Severity.Warning, dataAggregateObjResult.Arguments);
}
if (dataAggregateObjResult.ErrorOccurred)
{
throw new ReportProcessingException_InvalidOperationException();
}
}
if (dataAggregateObjResult.ErrorOccurred)
{
throw new ReportProcessingException(ErrorCode.rsInvalidOperation);
}
return(dataAggregateObjResult.Value);
}
internal virtual void AddScopedRunningValue(Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj runningValueObj)
{
if (m_scopedRunningValues == null)
{
m_scopedRunningValues = new List <string>();
}
if (!m_scopedRunningValues.Contains(runningValueObj.Name))
{
m_scopedRunningValues.Add(runningValueObj.Name);
}
}
internal Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj GetAggregateObj(string name)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = (Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj)m_collection[name];
if (dataAggregateObj == null && m_duplicateNames != null)
{
string text = (string)m_duplicateNames[name];
if (text != null)
{
dataAggregateObj = (Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj)m_collection[text];
}
}
return(dataAggregateObj);
}
internal static void AddRunningValues(OnDemandProcessingContext odpContext, List <Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, ref List <string> runningValuesInGroup, ref List <string> previousValuesInGroup, Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection, IReference <RuntimeGroupRootObj> lastGroup)
{
if (runningValues == null || 0 >= runningValues.Count)
{
return;
}
if (runningValuesInGroup == null)
{
runningValuesInGroup = new List <string>();
}
if (previousValuesInGroup == null)
{
previousValuesInGroup = new List <string>();
}
AggregatesImpl aggregatesImpl = odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < runningValues.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo runningValueInfo = runningValues[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregatesImpl.GetAggregateObj(runningValueInfo.Name);
if (dataAggregateObj == null)
{
dataAggregateObj = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(runningValueInfo, odpContext);
aggregatesImpl.Add(dataAggregateObj);
}
if (runningValueInfo.Scope != null)
{
if (groupCollection.TryGetValue(runningValueInfo.Scope, out IReference <RuntimeGroupRootObj> value))
{
using (value.PinValue())
{
value.Value().AddScopedRunningValue(dataAggregateObj);
}
}
else
{
Global.Tracer.Assert(condition: false);
}
}
if (runningValueInfo.AggregateType == Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Previous)
{
previousValuesInGroup.Add(dataAggregateObj.Name);
}
else
{
runningValuesInGroup.Add(dataAggregateObj.Name);
}
}
}
internal void Add(Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj newObject)
{
Global.Tracer.Assert(!newObject.NonAggregateMode, "( !newObject.NonAggregateMode )");
try
{
if (m_lockAdd)
{
Monitor.Enter(m_collection);
}
m_collection.Add(newObject.Name, newObject);
PopulateDuplicateNames(newObject.Name, newObject.DuplicateNames);
}
finally
{
if (m_lockAdd)
{
Monitor.Exit(m_collection);
}
}
}
protected void SetupAggregates(List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates)
{
if (aggregates != null)
{
for (int i = 0; i < aggregates.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregates[i];
m_odpContext.ReportObjectModel.AggregatesImpl.Set(dataAggregateObj.Name, dataAggregateObj.AggregateDef, dataAggregateObj.DuplicateNames, dataAggregateObj.AggregateResult());
}
}
}
internal static void UpdateAggregates(OnDemandProcessingContext odpContext, List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates, bool updateAndSetup)
{
if (aggregates == null)
{
return;
}
for (int i = 0; i < aggregates.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregates[i];
dataAggregateObj.Update();
if (updateAndSetup)
{
odpContext.ReportObjectModel.AggregatesImpl.Set(dataAggregateObj.Name, dataAggregateObj.AggregateDef, dataAggregateObj.DuplicateNames, dataAggregateObj.AggregateResult());
}
}
}
internal static void CreateAggregates <AggregateType>(OnDemandProcessingContext odpContext, List <AggregateType> aggDefs, List <int> aggregateIndexes, ref List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates) where AggregateType : Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo
{
if (aggregateIndexes != null && 0 < aggregateIndexes.Count)
{
for (int i = 0; i < aggregateIndexes.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregate = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(aggDefs[aggregateIndexes[i]], odpContext);
AddAggregate(ref aggregates, aggregate);
}
}
}
internal static void CreateAggregates <AggregateType>(OnDemandProcessingContext odpContext, BucketedAggregatesCollection <AggregateType> aggDefs, ref BucketedDataAggregateObjs aggregates) where AggregateType : Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo
{
if (aggDefs == null || aggDefs.IsEmpty)
{
return;
}
if (aggregates == null)
{
aggregates = new BucketedDataAggregateObjs();
}
foreach (AggregateBucket <AggregateType> bucket in aggDefs.Buckets)
{
foreach (AggregateType aggregate in bucket.Aggregates)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj item = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(aggregate, odpContext);
aggregates.GetOrCreateBucket(bucket.Level).Aggregates.Add(item);
}
}
}
internal static void CreateAggregates(OnDemandProcessingContext odpContext, List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo> aggDefs, List <int> aggregateIndexes, ref List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj> nonCustomAggregates, ref List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj> customAggregates)
{
if (aggregateIndexes == null || 0 >= aggregateIndexes.Count)
{
return;
}
for (int i = 0; i < aggregateIndexes.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo dataAggregateInfo = aggDefs[aggregateIndexes[i]];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregate = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(dataAggregateInfo, odpContext);
if (Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Aggregate == dataAggregateInfo.AggregateType)
{
AddAggregate(ref customAggregates, aggregate);
}
else
{
AddAggregate(ref nonCustomAggregates, aggregate);
}
}
}
internal static void AddAggregate(ref List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates, Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregate)
{
if (aggregates == null)
{
aggregates = new List <Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>();
}
aggregates.Add(aggregate);
}
internal override void CalculatePreviousAggregates()
{
if (!FlagUtils.HasFlag(m_dataAction, DataActions.PostSortAggregates))
{
return;
}
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
if (m_hierarchyDef.DataRegionDef.ProcessCellRunningValues)
{
if (m_cellPreviousValues != null)
{
for (int i = 0; i < m_cellPreviousValues.Count; i++)
{
string text = m_cellPreviousValues[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected previous aggregate: {0}", text);
aggregateObj.Update();
}
}
if (m_outerScope != null && (m_outerDataAction & DataActions.PostSortAggregates) != 0)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().CalculatePreviousAggregates();
}
}
return;
}
if (m_staticCellPreviousValues != null)
{
for (int j = 0; j < m_staticCellPreviousValues.Count; j++)
{
string text2 = m_staticCellPreviousValues[j];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj2 = aggregatesImpl.GetAggregateObj(text2);
Global.Tracer.Assert(aggregateObj2 != null, "Missing expected previous aggregate: {0}", text2);
aggregateObj2.Update();
}
}
base.CalculatePreviousAggregates();
}
public override object this[string key]
{
get
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = GetAggregateObj(key);
if (aggregateObj == null)
{
if (m_odpContext.IsTablixProcessingMode)
{
m_odpContext.ReportRuntime.UnfulfilledDependency = true;
}
if (!m_odpContext.CalculateAggregate(key))
{
return(null);
}
aggregateObj = GetAggregateObj(key);
Global.Tracer.Assert(aggregateObj != null, "(null != aggregateObj)");
}
object aggregateValue = GetAggregateValue(key, aggregateObj);
if (aggregateValue == null && aggregateObj.AggregateDef.AggregateType == Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Aggregate && m_odpContext.StreamingMode && m_odpContext.StateManager.CheckForPrematureServerAggregate(key))
{
aggregateValue = GetAggregateValue(key, GetAggregateObj(key));
}
return(aggregateValue);
}
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (DataActions.PostSortAggregates == dataAction && m_runningValuesInGroup != null)
{
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < m_runningValuesInGroup.Count; i++)
{
string text = m_runningValuesInGroup[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected running value aggregate: {0}", text);
aggregateObj.Update();
}
}
if (m_outerScope != null && (dataAction & m_outerDataAction) != 0)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().ReadRow(dataAction, context);
}
}
}
internal static void StoreRunningValues(AggregatesImpl globalRVCol, List <Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, ref Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[] runningValueValues)
{
if (runningValues != null && 0 < runningValues.Count)
{
if (runningValueValues == null)
{
runningValueValues = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[runningValues.Count];
}
for (int i = 0; i < runningValues.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo runningValueInfo = runningValues[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = globalRVCol.GetAggregateObj(runningValueInfo.Name);
if (aggregateObj != null)
{
runningValueValues[i] = aggregateObj.AggregateResult();
}
}
}
else
{
runningValueValues = null;
}
}
private void PageInit(ReportSection section)
{
ObjectModelImpl reportObjectModel = m_processingContext.ReportObjectModel;
AggregatesImpl aggregatesImpl = reportObjectModel.AggregatesImpl;
Global.Tracer.Assert(section.BodyItemsForHeadFoot != null, "Missing cached BodyItemsForHeadFoot collection");
Global.Tracer.Assert(section.PageSectionItemsForHeadFoot != null, "Missing cached PageSectionItemsForHeadFoot collection");
section.BodyItemsForHeadFoot.ResetAll(default(Microsoft.ReportingServices.RdlExpressions.VariantResult));
section.PageSectionItemsForHeadFoot.ResetAll();
reportObjectModel.GlobalsImpl.SetPageNumbers(m_currentPageNumber, m_totalPages, m_currentOverallPageNumber, m_overallTotalPages);
reportObjectModel.GlobalsImpl.SetPageName(m_pageName);
_ = m_romReport.ReportDef;
Microsoft.ReportingServices.ReportIntermediateFormat.ReportSection sectionDef = section.SectionDef;
Microsoft.ReportingServices.ReportIntermediateFormat.Page page = sectionDef.Page;
section.PageAggregatesOverReportItems = new Dictionary <string, AggregatesImpl>();
m_processingContext.ReportObjectModel.ReportItemsImpl.SpecialMode = true;
if (page.PageAggregates != null)
{
for (int i = 0; i < page.PageAggregates.Count; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateInfo dataAggregateInfo = page.PageAggregates[i];
aggregatesImpl.Remove(dataAggregateInfo);
dataAggregateInfo.ExprHostInitialized = false;
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj(dataAggregateInfo, m_processingContext);
dataAggregateObj.EvaluateParameters(out object[] _, out DataFieldStatus _);
string specialModeIndex = reportObjectModel.ReportItemsImpl.GetSpecialModeIndex();
if (specialModeIndex == null)
{
aggregatesImpl.Add(dataAggregateObj);
}
else
{
if (!section.PageAggregatesOverReportItems.TryGetValue(specialModeIndex, out AggregatesImpl value))
{
value = new AggregatesImpl(m_processingContext);
section.PageAggregatesOverReportItems.Add(specialModeIndex, value);
}
value.Add(dataAggregateObj);
m_reportItemToReportSection[specialModeIndex] = section;
}
dataAggregateObj.Init();
}
}
reportObjectModel.ReportItemsImpl.SpecialMode = false;
Microsoft.ReportingServices.ReportIntermediateFormat.PageSection rifObject = null;
IReportScopeInstance romInstance = null;
if (sectionDef.Page.PageHeader != null)
{
rifObject = sectionDef.Page.PageHeader;
romInstance = section.Page.PageHeader.Instance.ReportScopeInstance;
section.Page.PageHeader.SetNewContext();
}
if (sectionDef.Page.PageFooter != null)
{
rifObject = sectionDef.Page.PageFooter;
romInstance = section.Page.PageFooter.Instance.ReportScopeInstance;
section.Page.PageFooter.SetNewContext();
}
if (sectionDef != null)
{
m_processingContext.SetupContext(rifObject, romInstance);
}
}
internal void SetupCellRunningValues(Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[] cellRunningValueValues)
{
if (cellRunningValueValues == null)
{
return;
}
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
int num = (m_staticCellPreviousValues != null) ? m_staticCellPreviousValues.Count : 0;
int num2 = (m_staticCellRVs != null) ? m_staticCellRVs.Count : 0;
if (num2 > 0)
{
for (int i = 0; i < num2; i++)
{
string text = m_staticCellRVs[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected running value: {0}", text);
aggregateObj.Set(cellRunningValueValues[i]);
}
}
if (num > 0)
{
for (int j = 0; j < num; j++)
{
string text2 = m_staticCellPreviousValues[j];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj2 = aggregatesImpl.GetAggregateObj(text2);
Global.Tracer.Assert(aggregateObj2 != null, "Missing expected running value: {0}", text2);
aggregateObj2.Set(cellRunningValueValues[num2 + j]);
}
}
}
internal void DoneReadingRows(ref Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[] runningValueValues, ref Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[] runningValueOfAggregateValues, ref Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[] cellRunningValueValues)
{
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
RuntimeRICollection.StoreRunningValues(aggregatesImpl, m_hierarchyDef.RunningValues, ref runningValueValues);
if (m_hierarchyDef.DataScopeInfo != null)
{
RuntimeRICollection.StoreRunningValues(aggregatesImpl, m_hierarchyDef.DataScopeInfo.RunningValuesOfAggregates, ref runningValueOfAggregateValues);
}
int num = (m_staticCellPreviousValues != null) ? m_staticCellPreviousValues.Count : 0;
int num2 = (m_staticCellRVs != null) ? m_staticCellRVs.Count : 0;
if (num2 > 0)
{
cellRunningValueValues = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[num2 + num];
for (int i = 0; i < num2; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(m_staticCellRVs[i]);
cellRunningValueValues[i] = aggregateObj.AggregateResult();
}
}
if (num > 0)
{
if (cellRunningValueValues == null)
{
cellRunningValueValues = new Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[num];
}
for (int j = 0; j < num; j++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj2 = aggregatesImpl.GetAggregateObj(m_staticCellPreviousValues[j]);
cellRunningValueValues[num2 + j] = aggregateObj2.AggregateResult();
}
}
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (!FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregates) || !FlagUtils.HasFlag(m_dataAction, DataActions.PostSortAggregates))
{
return;
}
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
if (m_hierarchyDef.DataRegionDef.ProcessCellRunningValues)
{
if (m_cellRVs != null)
{
for (int i = 0; i < m_cellRVs.Count; i++)
{
string text = m_cellRVs[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected running value: {0}", text);
aggregateObj.Update();
}
}
if (m_outerScope != null && m_hierarchyDef.DataRegionDef.CellPostSortAggregates != null)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().ReadRow(dataAction, context);
}
}
return;
}
if (m_staticCellRVs != null)
{
for (int j = 0; j < m_staticCellRVs.Count; j++)
{
string text2 = m_staticCellRVs[j];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj2 = aggregatesImpl.GetAggregateObj(text2);
Global.Tracer.Assert(aggregateObj2 != null, "Missing expected running value: {0}", text2);
aggregateObj2.Update();
}
}
base.ReadRow(dataAction, context);
}
private void CalculateDRPreviousAggregates()
{
SetupEnvironment();
if (m_previousValues != null)
{
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < m_previousValues.Count; i++)
{
string text = m_previousValues[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected previous aggregate: {0}", text);
aggregateObj.Update();
}
}
}
internal override void CalculatePreviousAggregates()
{
if (m_previousValuesInGroup != null)
{
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < m_previousValuesInGroup.Count; i++)
{
string text = m_previousValuesInGroup[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected previous aggregate: {0}", text);
aggregateObj.Update();
}
}
if (m_outerScope != null && (m_outerDataAction & DataActions.PostSortAggregates) != 0)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().CalculatePreviousAggregates();
}
}
}
