private void CreateAggregates(List <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo> aggDefs)
{
if (aggDefs != null && 0 < aggDefs.Count)
{
AggregatesImpl aggregatesImpl = this.m_odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < aggDefs.Count; i++)
{
AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo dataAggregateInfo = aggDefs[i];
AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregatesImpl.GetAggregateObj(dataAggregateInfo.Name);
if (dataAggregateObj == null)
{
dataAggregateObj = new AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj(dataAggregateInfo, this.m_odpContext);
aggregatesImpl.Add(dataAggregateObj);
}
if (AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Previous != dataAggregateInfo.AggregateType)
{
if (AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Aggregate == dataAggregateInfo.AggregateType)
{
RuntimeDataRegionObj.AddAggregate(ref this.m_customAggregates, dataAggregateObj);
}
else
{
RuntimeDataRegionObj.AddAggregate(ref this.m_nonCustomAggregates, dataAggregateObj);
}
}
}
}
}
protected Hashtable GetScopeNames(RuntimeDataRegionObjReference currentScope, Dictionary <string, object> nameValuePairs)
{
Hashtable hashtable = new Hashtable();
IScope scope = null;
for (IReference <IScope> reference = currentScope; reference != null; reference = scope.GetOuterScope(false))
{
scope = reference.Value();
string scopeName = scope.GetScopeName();
if (scopeName != null)
{
AspNetCore.ReportingServices.ReportIntermediateFormat.Grouping grouping = null;
if (scope is RuntimeGroupLeafObj)
{
grouping = ((RuntimeGroupLeafObj)scope).GroupingDef;
RuntimeDataRegionObj.AddGroupNameValuePair(this.m_odpContext, grouping, nameValuePairs);
}
hashtable.Add(scopeName, grouping);
}
else if (scope is RuntimeTablixCell)
{
scope.GetGroupNameValuePairs(nameValuePairs);
}
}
return(hashtable);
}
public void RegisterSortFilterExpressionScope(IReference <IScope> containerRef, IReference <RuntimeDataRegionObj> scopeRef, bool[] isSortFilterExpressionScope)
{
List <IReference <RuntimeSortFilterEventInfo> > runtimeSortFilterInfo = this.m_runtimeSortFilterInfo;
if (runtimeSortFilterInfo != null && isSortFilterExpressionScope != null && scopeRef != null)
{
List <object>[] array = null;
using (scopeRef.PinValue())
{
RuntimeDataRegionObj runtimeDataRegionObj = scopeRef.Value();
using (containerRef.PinValue())
{
IScope scope = containerRef.Value();
for (int i = 0; i < runtimeSortFilterInfo.Count; i++)
{
if (isSortFilterExpressionScope[i] && runtimeDataRegionObj.IsTargetForSort(i, false) && runtimeDataRegionObj.TargetScopeMatched(i, false))
{
IReference <RuntimeSortFilterEventInfo> reference = runtimeSortFilterInfo[i];
using (reference.PinValue())
{
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = reference.Value();
if (array == null && runtimeSortFilterEventInfo.EventSource.UserSort.GroupsInSortTarget != null)
{
int num = 0;
array = new List <object> [runtimeSortFilterEventInfo.EventSource.UserSort.GroupsInSortTarget.Count];
runtimeDataRegionObj.GetScopeValues(runtimeSortFilterEventInfo.EventTarget, array, ref num);
}
runtimeSortFilterEventInfo.RegisterSortFilterExpressionScope(ref scope.SortFilterExpressionScopeInfoIndices[i], scopeRef, array, i);
}
}
}
}
}
}
}
public override void UpdateAggregates(AggregateUpdateContext context)
{
this.SetupEnvironment();
if (RuntimeDataRegionObj.UpdateAggregatesAtScope(context, this, base.m_dataRegionDef.DataScopeInfo, AggregateUpdateFlags.Both, false))
{
this.Traverse(ProcessingStages.UpdateAggregates, context);
}
}
public static void CreateAggregates <AggregateType>(OnDemandProcessingContext odpContext, List <AggregateType> aggDefs, List <int> aggregateIndexes, ref List <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates) where AggregateType : AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo
{
if (aggregateIndexes != null && 0 < aggregateIndexes.Count)
{
for (int i = 0; i < aggregateIndexes.Count; i++)
{
AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregate = new AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj((AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo)(object) aggDefs[aggregateIndexes[i]], odpContext);
RuntimeDataRegionObj.AddAggregate(ref aggregates, aggregate);
}
}
}
public IReference <IDataCorrelation> GetIdcReceiver(IRIFReportDataScope scope)
{
if (scope.IsGroup)
{
AspNetCore.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember = scope as AspNetCore.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode;
IReference <RuntimeMemberObj>[] memberCollection = this.GetMemberCollection(rifMember);
return(RuntimeDataRegionObj.GetGroupRoot(rifMember, memberCollection));
}
AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion rifDataRegion = scope as AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion;
return(this.GetNestedDataRegion(rifDataRegion));
}
public RuntimeDataTablixObj(IReference <IScope> outerScope, AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataTablixDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, AspNetCore.ReportingServices.ReportProcessing.ObjectType objectType)
: base(outerScope, dataTablixDef, ref dataAction, odpContext, onePassProcess, dataTablixDef.RunningValues, objectType, outerScope.Value().Depth + 1)
{
bool handleMyDataAction = default(bool);
DataActions innerDataAction = default(DataActions);
this.ConstructorHelper(ref dataAction, onePassProcess, out handleMyDataAction, out innerDataAction);
base.m_innerDataAction = innerDataAction;
DataActions userSortDataAction = base.HandleSortFilterEvent();
this.ConstructRuntimeStructure(ref innerDataAction, onePassProcess);
this.HandleDataAction(handleMyDataAction, innerDataAction, userSortDataAction);
base.m_odpContext.CreatedScopeInstance(base.m_dataRegionDef);
this.m_scopeInstanceNumber = RuntimeDataRegionObj.AssignScopeInstanceNumber(base.m_dataRegionDef.DataScopeInfo);
}
private bool NextRegularRow()
{
if (base.m_odpContext.ReportObjectModel.FieldsImpl.AggregationFieldCount == 0)
{
this.m_hasProcessedAggregateRow = true;
RuntimeDataRegionObj.UpdateAggregates(base.m_odpContext, this.m_customAggregates, false);
}
if (base.m_odpContext.ReportObjectModel.FieldsImpl.IsAggregateRow)
{
base.ScopeNextAggregateRow(this.m_userSortTargetInfo);
return(false);
}
this.NextNonAggregateRow();
return(true);
}
protected void DataRegionGetGroupNameValuePairs(AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, Dictionary <string, object> nameValuePairs)
{
if (dataRegionDef.ScopeNames == null)
{
dataRegionDef.ScopeNames = this.GetScopeNames(this.SelfReference, nameValuePairs);
}
else
{
IEnumerator enumerator = dataRegionDef.ScopeNames.Values.GetEnumerator();
while (enumerator.MoveNext())
{
RuntimeDataRegionObj.AddGroupNameValuePair(this.m_odpContext, enumerator.Current as AspNetCore.ReportingServices.ReportIntermediateFormat.Grouping, nameValuePairs);
}
}
}
public override bool SortAndFilter(AggregateUpdateContext aggContext)
{
this.SetupEnvironment();
if (base.m_userSortTargetInfo != null)
{
base.m_userSortTargetInfo.EnterProcessUserSortPhase(base.m_odpContext);
}
bool flag = base.DataRegionDef.ProcessingInnerGrouping == AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion.ProcessingInnerGroupings.Column;
IReference <RuntimeMemberObj>[] array = flag ? this.m_outerGroupings : this.m_innerGroupings;
IReference <RuntimeMemberObj>[] array2 = flag ? this.m_innerGroupings : this.m_outerGroupings;
int rowDomainScopeCount = base.DataRegionDef.RowDomainScopeCount;
int columnDomainScopeCount = base.DataRegionDef.ColumnDomainScopeCount;
DomainScopeContext domainScopeContext = base.OdpContext.DomainScopeContext;
AggregateUpdateQueue workQueue = null;
if (base.m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope))
{
workQueue = RuntimeDataRegionObj.AggregateOfAggregatesStart(aggContext, this, base.m_dataRegionDef.DataScopeInfo, base.m_aggregatesOfAggregates, AggregateUpdateFlags.Both, false);
if (rowDomainScopeCount > 0)
{
domainScopeContext.AddDomainScopes(array, array.Length - rowDomainScopeCount);
}
if (columnDomainScopeCount > 0)
{
domainScopeContext.AddDomainScopes(array2, array2.Length - columnDomainScopeCount);
}
}
this.Traverse(ProcessingStages.SortAndFilter, aggContext);
base.SortAndFilter(aggContext);
if (base.m_odpContext.HasSecondPassOperation(SecondPassOperations.FilteringOrAggregatesOrDomainScope))
{
RuntimeDataRegionObj.AggregatesOfAggregatesEnd(this, aggContext, workQueue, base.m_dataRegionDef.DataScopeInfo, base.m_aggregatesOfAggregates, true);
if (rowDomainScopeCount > 0)
{
domainScopeContext.RemoveDomainScopes(array, array.Length - rowDomainScopeCount);
}
if (columnDomainScopeCount > 0)
{
domainScopeContext.RemoveDomainScopes(array2, array2.Length - columnDomainScopeCount);
}
}
if (base.m_userSortTargetInfo != null)
{
base.m_userSortTargetInfo.LeaveProcessUserSortPhase(base.m_odpContext);
}
return(true);
}
protected static IOnDemandMemberInstanceReference GetFirstMemberInstance(AspNetCore.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember, IReference <RuntimeMemberObj>[] memberCol)
{
IOnDemandMemberInstanceReference result = null;
RuntimeDataTablixGroupRootObjReference groupRoot = RuntimeDataRegionObj.GetGroupRoot(rifMember, memberCol);
using (groupRoot.PinValue())
{
RuntimeDataTablixGroupRootObj runtimeDataTablixGroupRootObj = groupRoot.Value();
RuntimeGroupLeafObjReference firstChild = runtimeDataTablixGroupRootObj.FirstChild;
if ((BaseReference)firstChild != (object)null)
{
return((IOnDemandMemberInstanceReference)firstChild);
}
return(result);
}
}
private void CreateCells(IReference <RuntimeDataRegionObj> containingScopeRef, OnDemandProcessingContext odpContext, DataRegionInstance dataRegionInstance, bool isOuterGroup, IReference <RuntimeDataTablixGroupRootObj> currOuterGroupRoot, ScopeInstance parentInstance, IReference <RuntimeMemberObj>[] innerMembers, IReference <RuntimeDataTablixGroupLeafObj> innerGroupLeafRef)
{
using (containingScopeRef.PinValue())
{
RuntimeDataRegionObj runtimeDataRegionObj = containingScopeRef.Value();
if (runtimeDataRegionObj is RuntimeDataTablixGroupLeafObj)
{
RuntimeDataTablixGroupLeafObj runtimeDataTablixGroupLeafObj = (RuntimeDataTablixGroupLeafObj)runtimeDataRegionObj;
runtimeDataTablixGroupLeafObj.CreateStaticCells(dataRegionInstance, parentInstance, currOuterGroupRoot, isOuterGroup, this.m_staticLeafCellIndexes, innerMembers, innerGroupLeafRef);
}
else
{
((RuntimeDataTablixObj)runtimeDataRegionObj).CreateOutermostStaticCells(dataRegionInstance, isOuterGroup, innerMembers, innerGroupLeafRef);
}
}
}
public static void CreateAggregates(OnDemandProcessingContext odpContext, List <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo> aggDefs, ref List <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj> nonCustomAggregates, ref List <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj> customAggregates)
{
if (aggDefs != null && 0 < aggDefs.Count)
{
for (int i = 0; i < aggDefs.Count; i++)
{
AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregate = new AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj(aggDefs[i], odpContext);
if (AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Aggregate == aggDefs[i].AggregateType)
{
RuntimeDataRegionObj.AddAggregate(ref customAggregates, aggregate);
}
else
{
RuntimeDataRegionObj.AddAggregate(ref nonCustomAggregates, aggregate);
}
}
}
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (DataActions.UserSort == dataAction)
{
RuntimeDataRegionObj.CommonFirstRow(base.m_odpContext, ref base.m_firstRowIsAggregate, ref base.m_firstRow);
base.CommonNextRow(base.m_dataRows);
}
else if (DataActions.AggregatesOfAggregates == dataAction)
{
AggregateUpdateContext aggregateUpdateContext = (AggregateUpdateContext)context;
aggregateUpdateContext.UpdateAggregatesForRow();
}
else
{
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregatesOfAggregates))
{
AggregateUpdateContext aggregateUpdateContext2 = (AggregateUpdateContext)context;
aggregateUpdateContext2.UpdateAggregatesForRow();
}
if (!base.m_dataRegionDef.ProcessCellRunningValues)
{
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregates))
{
if (base.m_postSortAggregates != null)
{
RuntimeDataRegionObj.UpdateAggregates(base.m_odpContext, base.m_postSortAggregates, false);
}
if (base.m_runningValues != null)
{
RuntimeDataTablixObj.UpdateRunningValues(base.m_odpContext, base.m_runningValues);
}
}
if (base.m_outerScope != null && (dataAction & base.m_outerDataAction) != 0)
{
using (base.m_outerScope.PinValue())
{
IScope scope = base.m_outerScope.Value();
scope.ReadRow(dataAction, context);
}
}
}
}
}
public RuntimeRDLDataRegionObj(IReference <IScope> outerScope, AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, List <AspNetCore.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, AspNetCore.ReportingServices.ReportProcessing.ObjectType objectType, int level)
: base(odpContext, objectType, level)
{
this.m_dataRegionDef = dataRegionDef;
this.m_outerScope = outerScope;
RuntimeDataRegionObj.CreateAggregates(base.m_odpContext, dataRegionDef.Aggregates, ref this.m_nonCustomAggregates, ref this.m_customAggregates);
if (dataRegionDef.DataScopeInfo != null)
{
RuntimeDataRegionObj.CreateAggregates <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>(base.m_odpContext, (BucketedAggregatesCollection <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>)dataRegionDef.DataScopeInfo.AggregatesOfAggregates, ref this.m_aggregatesOfAggregates);
}
if (dataRegionDef.Filters != null)
{
this.m_filters = new Filters(Filters.FilterTypes.DataRegionFilter, (IReference <AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.IFilterOwner>)base.SelfReference, dataRegionDef.Filters, dataRegionDef.ObjectType, dataRegionDef.Name, base.m_odpContext, level + 1);
}
else
{
this.m_outerDataAction = dataAction;
this.m_dataAction = dataAction;
dataAction = DataActions.None;
}
}
public 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)
{
RuntimeDataRegionObj.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)
{
RuntimeDataRegionObj.UpdateAggregatesAtScope(aggContext, scope, dataScopeInfo, updateFlags, needsSetupEnvironment);
}
}
else
{
Global.Tracer.Assert(false, "Unknown AggregateMode for AggregateOfAggregatesStart");
}
return(result);
}
protected void ScopeNextNonAggregateRow(List <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj> aggregates, ScalableList <DataFieldRow> dataRows)
{
RuntimeDataRegionObj.UpdateAggregates(this.m_odpContext, aggregates, true);
this.CommonNextRow(dataRows);
}
void IDataRowSortOwner.PostDataRowSortNextRow()
{
RuntimeDataRegionObj.CommonFirstRow(base.m_odpContext, ref this.m_firstRowIsAggregate, ref this.m_firstRow);
base.ScopeNextNonAggregateRow(this.m_nonCustomAggregates, this.m_dataRows);
}
public override void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext)
{
if (base.m_dataRegionDef.RunningValues != null && base.m_runningValues == null && base.m_previousValues == null)
{
RuntimeDataTablixObj.AddRunningValues(base.m_odpContext, base.m_dataRegionDef.RunningValues, ref base.m_runningValues, ref base.m_previousValues, groupCol, lastGroup);
}
if (base.m_dataRegionDef.DataScopeInfo != null)
{
List <string> list = null;
List <string> list2 = null;
RuntimeDataTablixObj.AddRunningValues(base.m_odpContext, base.m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref list, ref list2, groupCol, lastGroup);
}
bool flag = base.m_dataRows != null && FlagUtils.HasFlag(base.m_dataAction, DataActions.PostSortAggregates);
AggregateUpdateQueue workQueue = RuntimeDataRegionObj.AggregateOfAggregatesStart(aggContext, this, base.m_dataRegionDef.DataScopeInfo, base.m_postSortAggregatesOfAggregates, (AggregateUpdateFlags)(flag ? 1 : 3), true);
if (flag)
{
DataActions dataActions = DataActions.PostSortAggregates;
if (aggContext.LastScopeNeedsRowAggregateProcessing())
{
dataActions |= DataActions.PostSortAggregatesOfAggregates;
}
base.ReadRows(dataActions, aggContext);
base.m_dataRows = null;
}
int num = (this.m_outerGroupings != null) ? this.m_outerGroupings.Length : 0;
if (num == 0)
{
if (this.m_innerGroupings != null)
{
for (int i = 0; i < this.m_innerGroupings.Length; i++)
{
IReference <RuntimeMemberObj> reference = this.m_innerGroupings[i];
using (reference.PinValue())
{
reference.Value().CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
}
}
else
{
for (int j = 0; j < num; j++)
{
IReference <RuntimeMemberObj> reference2 = this.m_outerGroupings[j];
bool flag2 = default(bool);
using (reference2.PinValue())
{
RuntimeMemberObj runtimeMemberObj = reference2.Value();
runtimeMemberObj.CalculateRunningValues(groupCol, lastGroup, aggContext);
flag2 = ((BaseReference)runtimeMemberObj.GroupRoot == (object)null);
}
if (flag2 && this.m_innerGroupings != null)
{
for (int k = 0; k < this.m_innerGroupings.Length; k++)
{
IReference <RuntimeMemberObj> reference3 = this.m_innerGroupings[k];
using (reference3.PinValue())
{
RuntimeMemberObj runtimeMemberObj2 = reference3.Value();
runtimeMemberObj2.PrepareCalculateRunningValues();
runtimeMemberObj2.CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
}
}
}
this.CalculateRunningValuesForTopLevelStaticContents(groupCol, lastGroup, aggContext);
RuntimeDataRegionObj.AggregatesOfAggregatesEnd(this, aggContext, workQueue, base.m_dataRegionDef.DataScopeInfo, base.m_postSortAggregatesOfAggregates, true);
this.CalculateDRPreviousAggregates();
RuntimeRICollection.StoreRunningValues(base.m_odpContext.ReportObjectModel.AggregatesImpl, base.m_dataRegionDef.RunningValues, ref base.m_runningValueValues);
if (base.m_dataRegionDef.DataScopeInfo != null)
{
RuntimeRICollection.StoreRunningValues(base.m_odpContext.ReportObjectModel.AggregatesImpl, base.m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref base.m_runningValueOfAggregateValues);
}
}
public IOnDemandMemberInstanceReference GetFirstMemberInstance(AspNetCore.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember)
{
IReference <RuntimeMemberObj>[] memberCollection = this.GetMemberCollection(rifMember);
return(RuntimeDataRegionObj.GetFirstMemberInstance(rifMember, memberCollection));
}
protected void SetupRunningValues(List <AspNetCore.ReportingServices.ReportIntermediateFormat.RunningValueInfo> rvDefs, AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult[] rvValues)
{
int num = 0;
RuntimeDataRegionObj.SetupRunningValues(this.m_odpContext, ref num, rvDefs, rvValues);
}
protected void SetupAggregates(BucketedDataAggregateObjs aggregates)
{
RuntimeDataRegionObj.SetupAggregates(this.m_odpContext, aggregates);
}
protected void ConstructorHelper(ref DataActions dataAction, bool onePassProcess, out bool handleMyDataAction, out DataActions innerDataAction)
{
innerDataAction = base.m_dataAction;
handleMyDataAction = false;
if (onePassProcess)
{
if (base.m_dataRegionDef.RunningValues != null && 0 < base.m_dataRegionDef.RunningValues.Count)
{
RuntimeDataRegionObj.CreateAggregates <AspNetCore.ReportingServices.ReportIntermediateFormat.RunningValueInfo>(base.m_odpContext, base.m_dataRegionDef.RunningValues, ref base.m_nonCustomAggregates);
}
RuntimeDataRegionObj.CreateAggregates <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>(base.m_odpContext, base.m_dataRegionDef.PostSortAggregates, ref base.m_nonCustomAggregates);
RuntimeDataRegionObj.CreateAggregates <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>(base.m_odpContext, base.m_dataRegionDef.CellPostSortAggregates, ref base.m_nonCustomAggregates);
}
else
{
if (base.m_dataRegionDef.RunningValues != null && 0 < base.m_dataRegionDef.RunningValues.Count)
{
base.m_dataAction |= DataActions.PostSortAggregates;
}
if (base.m_dataRegionDef.PostSortAggregates != null && base.m_dataRegionDef.PostSortAggregates.Count != 0)
{
RuntimeDataRegionObj.CreateAggregates <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>(base.m_odpContext, base.m_dataRegionDef.PostSortAggregates, ref base.m_postSortAggregates);
base.m_dataAction |= DataActions.PostSortAggregates;
handleMyDataAction = true;
}
if (base.m_dataRegionDef.DataScopeInfo != null)
{
DataScopeInfo dataScopeInfo = base.m_dataRegionDef.DataScopeInfo;
if (dataScopeInfo.PostSortAggregatesOfAggregates != null && !dataScopeInfo.PostSortAggregatesOfAggregates.IsEmpty)
{
RuntimeDataRegionObj.CreateAggregates <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>(base.m_odpContext, (BucketedAggregatesCollection <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>)dataScopeInfo.PostSortAggregatesOfAggregates, ref base.m_postSortAggregatesOfAggregates);
}
if (dataScopeInfo.HasAggregatesToUpdateAtRowScope)
{
base.m_dataAction |= DataActions.AggregatesOfAggregates;
handleMyDataAction = true;
}
}
if (handleMyDataAction)
{
innerDataAction = DataActions.None;
}
else
{
innerDataAction = base.m_dataAction;
}
}
base.m_inDataRowSortPhase = (base.m_dataRegionDef.Sorting != null && base.m_dataRegionDef.Sorting.ShouldApplySorting);
if (base.m_inDataRowSortPhase)
{
base.m_sortedDataRowTree = new BTree(this, base.m_odpContext, base.m_depth);
base.m_dataRowSortExpression = new RuntimeExpressionInfo(base.m_dataRegionDef.Sorting.SortExpressions, base.m_dataRegionDef.Sorting.ExprHost, base.m_dataRegionDef.Sorting.SortDirections, 0);
base.m_odpContext.AddSpecialDataRowSort((IReference <IDataRowSortOwner>)base.SelfReference);
}
base.m_dataRegionDef.ResetInstanceIndexes();
this.m_outerGroupingCounters = new int[base.m_dataRegionDef.OuterGroupingDynamicMemberCount];
for (int i = 0; i < this.m_outerGroupingCounters.Length; i++)
{
this.m_outerGroupingCounters[i] = -1;
}
}
