private void Traverse(ProcessingStages operation, AggregateUpdateContext aggContext)
{
if (m_grouping != null)
{
m_grouping.Traverse(ProcessingStages.SortAndFilter, ascending: true, aggContext);
}
if (m_hierarchyObjs == null)
{
return;
}
for (int i = 0; i < m_hierarchyObjs.Count; i++)
{
IReference <RuntimeHierarchyObj> reference = m_hierarchyObjs[i];
using (reference.PinValue())
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
reference.Value().SortAndFilter(aggContext);
break;
case ProcessingStages.UpdateAggregates:
reference.Value().UpdateAggregates(aggContext);
break;
}
}
}
}
private void SortAndFilter()
{
if (m_report.NeedPostGroupProcessing)
{
m_odpContext.SecondPassOperation = (m_report.HasVariables ? SecondPassOperations.Variables : SecondPassOperations.None);
if (m_report.HasSpecialRecursiveAggregates)
{
m_odpContext.SecondPassOperation |= SecondPassOperations.FilteringOrAggregatesOrDomainScope;
}
else
{
m_odpContext.SecondPassOperation |= (SecondPassOperations.Sorting | SecondPassOperations.FilteringOrAggregatesOrDomainScope);
}
AggregateUpdateContext aggContext = new AggregateUpdateContext(m_odpContext, AggregateMode.Aggregates);
m_dataSetObj.EnterProcessUserSortPhase();
m_odpContext.DomainScopeContext = new DomainScopeContext();
m_dataSetObj.SortAndFilter(aggContext);
m_odpContext.DomainScopeContext = null;
if (m_report.HasSpecialRecursiveAggregates)
{
m_odpContext.SecondPassOperation = SecondPassOperations.Sorting;
m_dataSetObj.SortAndFilter(aggContext);
}
m_dataSetObj.LeaveProcessUserSortPhase();
}
}
internal virtual void CalculateRunningValues(AggregateUpdateContext aggContext)
{
if (m_grouping != null)
{
m_grouping.Traverse(ProcessingStages.RunningValues, m_expression == null || m_expression.Direction, aggContext);
}
if (m_hierarchyObjs == null)
{
return;
}
bool flag = true;
for (int i = 0; i < m_hierarchyObjs.Count; i++)
{
IReference <RuntimeHierarchyObj> reference = m_hierarchyObjs[i];
using (reference.PinValue())
{
RuntimeHierarchyObj runtimeHierarchyObj = reference.Value();
if (!flag || runtimeHierarchyObj is RuntimeGroupLeafObj)
{
((RuntimeGroupLeafObj)runtimeHierarchyObj).TraverseAllLeafNodes(ProcessingStages.RunningValues, aggContext);
flag = false;
}
}
}
}
private void Traverse(ProcessingStages operation, AggregateUpdateContext context)
{
if (Count == 0)
{
return;
}
int num = m_firstCellKey;
int num2;
do
{
num2 = num;
IDisposable cleanupRef;
RuntimeCell andPinCell = GetAndPinCell(num2, out cleanupRef);
switch (operation)
{
case ProcessingStages.SortAndFilter:
andPinCell.SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
andPinCell.UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown operation in Traverse");
break;
}
num = andPinCell.NextCell;
cleanupRef?.Dispose();
}
while (num2 != m_lastCellKey);
}
private void Traverse(ProcessingStages operation, AggregateUpdateContext context)
{
for (int i = 0; i < m_dataRegionObjs.Count; i++)
{
RuntimeDataRegionObjReference runtimeDataRegionObjReference = m_dataRegionObjs[i];
if (!(runtimeDataRegionObjReference != null))
{
continue;
}
using (runtimeDataRegionObjReference.PinValue())
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
runtimeDataRegionObjReference.Value().SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
runtimeDataRegionObjReference.Value().UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown ProcessingStage in Traverse");
break;
}
}
}
}
public void SortAndFilter(AggregateUpdateContext aggContext)
{
if (m_runtimeDataRegions != null)
{
m_runtimeDataRegions.SortAndFilter(aggContext);
}
}
public override void UpdateAggregates(AggregateUpdateContext context)
{
SetupEnvironment();
if (RuntimeDataRegionObj.UpdateAggregatesAtScope(context, this, m_dataRegionDef.DataScopeInfo, AggregateUpdateFlags.Both, needsSetupEnvironment: false))
{
Traverse(ProcessingStages.UpdateAggregates, context);
}
}
private void PostSortOperations()
{
if (m_report.HasPostSortAggregates)
{
Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection = new Dictionary <string, IReference <RuntimeGroupRootObj> >();
AggregateUpdateContext aggContext = new AggregateUpdateContext(m_odpContext, AggregateMode.PostSortAggregates);
m_dataSetObj.CalculateRunningValues(groupCollection, aggContext);
}
}
internal override bool SortAndFilter(AggregateUpdateContext aggContext)
{
if ((SecondPassOperations.FilteringOrAggregatesOrDomainScope & m_odpContext.SecondPassOperation) != 0 && m_dataRows != null && (m_outerDataAction & DataActions.RecursiveAggregates) != 0)
{
ReadRows(DataActions.RecursiveAggregates, null);
ReleaseDataRows(DataActions.RecursiveAggregates, ref m_dataAction, ref m_dataRows);
}
return true;
}
internal virtual void UpdateAggregates(AggregateUpdateContext aggContext)
{
if (null != m_groupRoot)
{
using (m_groupRoot.PinValue())
{
m_groupRoot.Value().UpdateAggregates(aggContext);
}
}
}
internal virtual bool SortAndFilter(AggregateUpdateContext aggContext)
{
if (null != m_groupRoot)
{
using (m_groupRoot.PinValue())
{
return(m_groupRoot.Value().SortAndFilter(aggContext));
}
}
return(true);
}
private void PreComputeAggregatesOfAggregates()
{
if (m_report.NeedPostGroupProcessing)
{
m_odpContext.SecondPassOperation = SecondPassOperations.FilteringOrAggregatesOrDomainScope;
AggregateUpdateContext aggContext = new AggregateUpdateContext(m_odpContext, AggregateMode.Aggregates);
m_odpContext.DomainScopeContext = new DomainScopeContext();
m_dataSetObj.SortAndFilter(aggContext);
m_odpContext.DomainScopeContext = null;
}
}
internal override bool SortAndFilter(AggregateUpdateContext aggContext)
{
if (m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope))
{
CopyDomainScopeGroupInstancesFromTarget();
}
RuntimeGroupingObj grouping = m_grouping;
bool ascending = DetermineTraversalDirection();
bool result = true;
bool processSecondPassSorting = ProcessSecondPassSorting;
bool flag = (SecondPassOperations.FilteringOrAggregatesOrDomainScope & m_odpContext.SecondPassOperation) != 0 && (m_hierarchyDef.HasFilters || m_hierarchyDef.HasInnerFilters);
if (processSecondPassSorting)
{
m_expression = new RuntimeExpressionInfo(m_hierarchyDef.Sorting.SortExpressions, m_hierarchyDef.Sorting.ExprHost, m_hierarchyDef.Sorting.SortDirections, 0);
m_groupingType = RuntimeGroupingObj.GroupingTypes.Sort;
m_grouping = new RuntimeGroupingObjTree(this, m_objectType);
}
else if (flag)
{
m_groupingType = RuntimeGroupingObj.GroupingTypes.None;
m_grouping = new RuntimeGroupingObjLinkedList(this, m_objectType);
}
if (flag)
{
m_groupFilters = new Filters(Filters.FilterTypes.GroupFilter, (IReference <Microsoft.ReportingServices.ReportProcessing.ReportProcessing.IFilterOwner>)base.SelfReference, m_hierarchyDef.Grouping.Filters, Microsoft.ReportingServices.ReportProcessing.ObjectType.Grouping, m_hierarchyDef.Grouping.Name, m_odpContext, base.Depth + 1);
}
m_processingStage = ProcessingStages.SortAndFilter;
m_lastChild = null;
grouping.Traverse(ProcessingStages.SortAndFilter, ascending, aggContext);
if (flag)
{
m_groupFilters.FinishReadingGroups(aggContext);
if (!processSecondPassSorting && null == m_lastChild)
{
if (m_firstChild != null)
{
m_firstChild.Free();
}
m_firstChild = null;
result = false;
}
}
if (grouping != m_grouping)
{
grouping.Cleanup();
}
return(result);
}
internal override bool SortAndFilter(AggregateUpdateContext aggContext)
{
SetupEnvironment();
if (m_userSortTargetInfo != null)
{
m_userSortTargetInfo.EnterProcessUserSortPhase(m_odpContext);
}
bool num = base.DataRegionDef.ProcessingInnerGrouping == Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion.ProcessingInnerGroupings.Column;
IReference <RuntimeMemberObj>[] array = num ? m_outerGroupings : m_innerGroupings;
IReference <RuntimeMemberObj>[] array2 = num ? m_innerGroupings : m_outerGroupings;
int rowDomainScopeCount = base.DataRegionDef.RowDomainScopeCount;
int columnDomainScopeCount = base.DataRegionDef.ColumnDomainScopeCount;
DomainScopeContext domainScopeContext = base.OdpContext.DomainScopeContext;
AggregateUpdateQueue workQueue = null;
if (m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope))
{
workQueue = RuntimeDataRegionObj.AggregateOfAggregatesStart(aggContext, this, m_dataRegionDef.DataScopeInfo, m_aggregatesOfAggregates, AggregateUpdateFlags.Both, needsSetupEnvironment: false);
if (rowDomainScopeCount > 0)
{
domainScopeContext.AddDomainScopes(array, array.Length - rowDomainScopeCount);
}
if (columnDomainScopeCount > 0)
{
domainScopeContext.AddDomainScopes(array2, array2.Length - columnDomainScopeCount);
}
}
Traverse(ProcessingStages.SortAndFilter, aggContext);
base.SortAndFilter(aggContext);
if (m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope))
{
RuntimeDataRegionObj.AggregatesOfAggregatesEnd(this, aggContext, workQueue, m_dataRegionDef.DataScopeInfo, m_aggregatesOfAggregates, updateAggsIfNeeded: true);
if (rowDomainScopeCount > 0)
{
domainScopeContext.RemoveDomainScopes(array, array.Length - rowDomainScopeCount);
}
if (columnDomainScopeCount > 0)
{
domainScopeContext.RemoveDomainScopes(array2, array2.Length - columnDomainScopeCount);
}
}
if (m_userSortTargetInfo != null)
{
m_userSortTargetInfo.LeaveProcessUserSortPhase(m_odpContext);
}
return(true);
}
protected override void CalculateRunningValuesForStaticContents(AggregateUpdateContext aggContext)
{
if (!m_processHeading)
{
return;
}
RuntimeDataTablixGroupRootObjReference runtimeDataTablixGroupRootObjReference = (RuntimeDataTablixGroupRootObjReference)m_hierarchyRoot;
using (runtimeDataTablixGroupRootObjReference.PinValue())
{
Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection = runtimeDataTablixGroupRootObjReference.Value().GroupCollection;
RuntimeGroupRootObjReference lastGroup = runtimeDataTablixGroupRootObjReference;
if (m_groupScopedItems != null)
{
m_groupScopedItems.CalculateRunningValues(groupCollection, lastGroup, aggContext);
}
}
}
internal static void AggregatesOfAggregatesEnd(IScope scopeObj, AggregateUpdateContext aggContext, AggregateUpdateQueue workQueue, DataScopeInfo dataScopeInfo, BucketedDataAggregateObjs aggregatesOfAggregates, bool updateAggsIfNeeded)
{
if (dataScopeInfo == null)
{
return;
}
if (updateAggsIfNeeded)
{
while (aggContext.AdvanceQueue(workQueue))
{
scopeObj.UpdateAggregates(aggContext);
}
}
aggContext.RestoreOriginalState(workQueue);
if (aggContext.Mode == AggregateMode.Aggregates && dataScopeInfo.NeedsSeparateAofAPass && updateAggsIfNeeded)
{
scopeObj.UpdateAggregates(aggContext);
}
}
protected override void TraverseStaticContents(ProcessingStages operation, AggregateUpdateContext context)
{
if (m_groupScopedItems != null)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
m_groupScopedItems.SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
m_groupScopedItems.UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown operation in TraverseStaticContents.");
break;
}
}
}
protected override void TraverseCellContents(ProcessingStages operation, AggregateUpdateContext context)
{
if (m_cellContents != null)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
m_cellContents.SortAndFilter(context);
break;
case ProcessingStages.UpdateAggregates:
m_cellContents.UpdateAggregates(context);
break;
default:
Global.Tracer.Assert(condition: false, "Invalid operation for TraverseCellContents.");
break;
}
}
}
internal static AggregateUpdateQueue AggregateOfAggregatesStart(AggregateUpdateContext aggContext, IDataRowHolder scope, DataScopeInfo dataScopeInfo, BucketedDataAggregateObjs aggregatesOfAggregates, AggregateUpdateFlags updateFlags, bool needsSetupEnvironment)
{
if (dataScopeInfo == null)
{
return(null);
}
AggregateUpdateQueue result = null;
if (aggContext.Mode == AggregateMode.Aggregates)
{
if (dataScopeInfo.NeedsSeparateAofAPass)
{
result = aggContext.ReplaceAggregatesToUpdate(aggregatesOfAggregates);
}
else
{
result = aggContext.RegisterAggregatesToUpdate(aggregatesOfAggregates);
if (updateFlags != 0)
{
UpdateAggregatesAtScope(aggContext, scope, dataScopeInfo, updateFlags, needsSetupEnvironment);
}
}
}
else if (aggContext.Mode == AggregateMode.PostSortAggregates)
{
result = aggContext.RegisterAggregatesToUpdate(aggregatesOfAggregates);
result = aggContext.RegisterRunningValuesToUpdate(result, dataScopeInfo.RunningValuesOfAggregates);
if (updateFlags != 0)
{
UpdateAggregatesAtScope(aggContext, scope, dataScopeInfo, updateFlags, needsSetupEnvironment);
}
}
else
{
Global.Tracer.Assert(condition: false, "Unknown AggregateMode for AggregateOfAggregatesStart");
}
return(result);
}
internal override void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext)
{
if (m_dataRegionDef.RunningValues != null && m_runningValues == null && m_previousValues == null)
{
AddRunningValues(m_odpContext, m_dataRegionDef.RunningValues, ref m_runningValues, ref m_previousValues, groupCol, lastGroup);
}
if (m_dataRegionDef.DataScopeInfo != null)
{
List <string> runningValuesInGroup = null;
List <string> previousValuesInGroup = null;
AddRunningValues(m_odpContext, m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref runningValuesInGroup, ref previousValuesInGroup, groupCol, lastGroup);
}
bool flag = m_dataRows != null && FlagUtils.HasFlag(m_dataAction, DataActions.PostSortAggregates);
AggregateUpdateQueue workQueue = RuntimeDataRegionObj.AggregateOfAggregatesStart(aggContext, this, m_dataRegionDef.DataScopeInfo, m_postSortAggregatesOfAggregates, flag ? AggregateUpdateFlags.ScopedAggregates : AggregateUpdateFlags.Both, needsSetupEnvironment: true);
if (flag)
{
DataActions dataActions = DataActions.PostSortAggregates;
if (aggContext.LastScopeNeedsRowAggregateProcessing())
{
dataActions |= DataActions.PostSortAggregatesOfAggregates;
}
ReadRows(dataActions, aggContext);
m_dataRows = null;
}
int num = (m_outerGroupings != null) ? m_outerGroupings.Length : 0;
if (num == 0)
{
if (m_innerGroupings != null)
{
for (int i = 0; i < m_innerGroupings.Length; i++)
{
IReference <RuntimeMemberObj> reference = m_innerGroupings[i];
using (reference.PinValue())
{
reference.Value().CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
}
}
else
{
for (int j = 0; j < num; j++)
{
IReference <RuntimeMemberObj> reference2 = m_outerGroupings[j];
bool flag2;
using (reference2.PinValue())
{
RuntimeMemberObj runtimeMemberObj = reference2.Value();
runtimeMemberObj.CalculateRunningValues(groupCol, lastGroup, aggContext);
flag2 = (runtimeMemberObj.GroupRoot == null);
}
if (!flag2 || m_innerGroupings == null)
{
continue;
}
for (int k = 0; k < m_innerGroupings.Length; k++)
{
IReference <RuntimeMemberObj> reference3 = m_innerGroupings[k];
using (reference3.PinValue())
{
RuntimeMemberObj runtimeMemberObj2 = reference3.Value();
runtimeMemberObj2.PrepareCalculateRunningValues();
runtimeMemberObj2.CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
}
}
CalculateRunningValuesForTopLevelStaticContents(groupCol, lastGroup, aggContext);
RuntimeDataRegionObj.AggregatesOfAggregatesEnd(this, aggContext, workQueue, m_dataRegionDef.DataScopeInfo, m_postSortAggregatesOfAggregates, updateAggsIfNeeded: true);
CalculateDRPreviousAggregates();
RuntimeRICollection.StoreRunningValues(m_odpContext.ReportObjectModel.AggregatesImpl, m_dataRegionDef.RunningValues, ref m_runningValueValues);
if (m_dataRegionDef.DataScopeInfo != null)
{
RuntimeRICollection.StoreRunningValues(m_odpContext.ReportObjectModel.AggregatesImpl, m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref m_runningValueOfAggregateValues);
}
}
protected virtual void CalculateRunningValuesForTopLevelStaticContents(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext)
{
}
internal override void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext)
{
Global.Tracer.Assert(condition: false);
}
public abstract void UpdateAggregates(AggregateUpdateContext context);
protected override void CalculateInnerRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext)
{
if (m_cellContents != null)
{
m_cellContents.CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
internal virtual void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext)
{
if (null != m_groupRoot)
{
using (m_groupRoot.PinValue())
{
m_groupRoot.Value().CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
}
public override void UpdateAggregates(AggregateUpdateContext aggContext)
{
Traverse(ProcessingStages.UpdateAggregates, aggContext);
}
internal abstract bool SortAndFilter(AggregateUpdateContext aggContext);
internal abstract void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext);
internal static bool UpdateAggregatesAtScope(AggregateUpdateContext aggContext, IDataRowHolder scope, DataScopeInfo scopeInfo, AggregateUpdateFlags updateFlags, bool needsSetupEnvironment)
{
return(aggContext.UpdateAggregates(scopeInfo, scope, updateFlags, needsSetupEnvironment));
}
internal override bool SortAndFilter(AggregateUpdateContext aggContext)
{
Traverse(ProcessingStages.SortAndFilter, aggContext);
return(true);
}
