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