public void SortAndFilter(AggregateUpdateContext aggContext) { if (this.m_runtimeDataRegions != null) { this.m_runtimeDataRegions.SortAndFilter(aggContext); } }
private void Traverse(ProcessingStages operation, AggregateUpdateContext context) { if (this.Count != 0) { int num = this.m_firstCellKey; int num2; do { num2 = num; IDisposable disposable = default(IDisposable); RuntimeCell andPinCell = this.GetAndPinCell(num2, out disposable); switch (operation) { case ProcessingStages.SortAndFilter: andPinCell.SortAndFilter(context); break; case ProcessingStages.UpdateAggregates: andPinCell.UpdateAggregates(context); break; default: Global.Tracer.Assert(false, "Unknown operation in Traverse"); break; } num = andPinCell.NextCell; if (disposable != null) { disposable.Dispose(); } }while (num2 != this.m_lastCellKey); } }
private void Traverse(ProcessingStages operation, AggregateUpdateContext aggContext) { if (this.m_grouping != null) { this.m_grouping.Traverse(ProcessingStages.SortAndFilter, true, aggContext); } if (this.m_hierarchyObjs != null) { for (int i = 0; i < this.m_hierarchyObjs.Count; i++) { IReference <RuntimeHierarchyObj> reference = this.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 Traverse(ProcessingStages operation, AggregateUpdateContext context) { for (int i = 0; i < this.m_dataRegionObjs.Count; i++) { RuntimeDataRegionObjReference runtimeDataRegionObjReference = this.m_dataRegionObjs[i]; if ((BaseReference)runtimeDataRegionObjReference != (object)null) { 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(false, "Unknown ProcessingStage in Traverse"); break; } } } } }
private void SortAndFilter() { if (this.m_report.NeedPostGroupProcessing) { this.m_odpContext.SecondPassOperation = (SecondPassOperations)(this.m_report.HasVariables ? 1 : 0); if (this.m_report.HasSpecialRecursiveAggregates) { this.m_odpContext.SecondPassOperation |= SecondPassOperations.FilteringOrAggregatesOrDomainScope; } else { this.m_odpContext.SecondPassOperation |= (SecondPassOperations.Sorting | SecondPassOperations.FilteringOrAggregatesOrDomainScope); } AggregateUpdateContext aggContext = new AggregateUpdateContext(this.m_odpContext, AggregateMode.Aggregates); this.m_dataSetObj.EnterProcessUserSortPhase(); this.m_odpContext.DomainScopeContext = new DomainScopeContext(); this.m_dataSetObj.SortAndFilter(aggContext); this.m_odpContext.DomainScopeContext = null; if (this.m_report.HasSpecialRecursiveAggregates) { this.m_odpContext.SecondPassOperation = SecondPassOperations.Sorting; this.m_dataSetObj.SortAndFilter(aggContext); } this.m_dataSetObj.LeaveProcessUserSortPhase(); } }
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); } }
private void PostSortOperations() { if (this.m_report.HasPostSortAggregates) { Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection = new Dictionary <string, IReference <RuntimeGroupRootObj> >(); AggregateUpdateContext aggContext = new AggregateUpdateContext(this.m_odpContext, AggregateMode.PostSortAggregates); this.m_dataSetObj.CalculateRunningValues(groupCollection, aggContext); } }
public override bool SortAndFilter(AggregateUpdateContext aggContext) { if ((SecondPassOperations.FilteringOrAggregatesOrDomainScope & base.m_odpContext.SecondPassOperation) != 0 && this.m_dataRows != null && (this.m_outerDataAction & DataActions.RecursiveAggregates) != 0) { this.ReadRows(DataActions.RecursiveAggregates, null); base.ReleaseDataRows(DataActions.RecursiveAggregates, ref this.m_dataAction, ref this.m_dataRows); } return(true); }
public virtual void UpdateAggregates(AggregateUpdateContext aggContext) { if ((BaseReference)null != (object)this.m_groupRoot) { using (this.m_groupRoot.PinValue()) { this.m_groupRoot.Value().UpdateAggregates(aggContext); } } }
private void PreComputeAggregatesOfAggregates() { if (this.m_report.NeedPostGroupProcessing) { this.m_odpContext.SecondPassOperation = SecondPassOperations.FilteringOrAggregatesOrDomainScope; AggregateUpdateContext aggContext = new AggregateUpdateContext(this.m_odpContext, AggregateMode.Aggregates); this.m_odpContext.DomainScopeContext = new DomainScopeContext(); this.m_dataSetObj.SortAndFilter(aggContext); this.m_odpContext.DomainScopeContext = null; } }
public virtual bool SortAndFilter(AggregateUpdateContext aggContext) { if ((BaseReference)null != (object)this.m_groupRoot) { using (this.m_groupRoot.PinValue()) { return(this.m_groupRoot.Value().SortAndFilter(aggContext)); } } return(true); }
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 override void CalculateRunningValuesForStaticContents(AggregateUpdateContext aggContext) { if (base.m_processHeading) { RuntimeDataTablixGroupRootObjReference runtimeDataTablixGroupRootObjReference = (RuntimeDataTablixGroupRootObjReference)base.m_hierarchyRoot; using (runtimeDataTablixGroupRootObjReference.PinValue()) { RuntimeDataTablixGroupRootObj runtimeDataTablixGroupRootObj = runtimeDataTablixGroupRootObjReference.Value(); Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection = runtimeDataTablixGroupRootObj.GroupCollection; RuntimeGroupRootObjReference lastGroup = runtimeDataTablixGroupRootObjReference; if (this.m_groupScopedItems != null) { this.m_groupScopedItems.CalculateRunningValues(groupCollection, lastGroup, aggContext); } } } }
public static void AggregatesOfAggregatesEnd(IScope scopeObj, AggregateUpdateContext aggContext, AggregateUpdateQueue workQueue, DataScopeInfo dataScopeInfo, BucketedDataAggregateObjs aggregatesOfAggregates, bool updateAggsIfNeeded) { if (dataScopeInfo != null) { if (updateAggsIfNeeded) { while (aggContext.AdvanceQueue(workQueue)) { scopeObj.UpdateAggregates(aggContext); } } aggContext.RestoreOriginalState(workQueue); if (aggContext.Mode == AggregateMode.Aggregates && dataScopeInfo.NeedsSeparateAofAPass && updateAggsIfNeeded) { scopeObj.UpdateAggregates(aggContext); } } }
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); } } } } }
protected override void TraverseStaticContents(ProcessingStages operation, AggregateUpdateContext context) { if (this.m_groupScopedItems != null) { switch (operation) { case ProcessingStages.SortAndFilter: this.m_groupScopedItems.SortAndFilter(context); break; case ProcessingStages.UpdateAggregates: this.m_groupScopedItems.UpdateAggregates(context); break; default: Global.Tracer.Assert(false, "Unknown operation in TraverseStaticContents."); break; } } }
protected override void TraverseCellContents(ProcessingStages operation, AggregateUpdateContext context) { if (this.m_cellContents != null) { switch (operation) { case ProcessingStages.SortAndFilter: this.m_cellContents.SortAndFilter(context); break; case ProcessingStages.UpdateAggregates: this.m_cellContents.UpdateAggregates(context); break; default: Global.Tracer.Assert(false, "Invalid operation for TraverseCellContents."); break; } } }
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); }
public virtual void CalculateRunningValues(AggregateUpdateContext aggContext) { if (this.m_grouping != null) { this.m_grouping.Traverse(ProcessingStages.RunningValues, this.m_expression == null || this.m_expression.Direction, aggContext); } if (this.m_hierarchyObjs != null) { bool flag = true; for (int i = 0; i < this.m_hierarchyObjs.Count; i++) { IReference <RuntimeHierarchyObj> reference = this.m_hierarchyObjs[i]; using (reference.PinValue()) { RuntimeHierarchyObj runtimeHierarchyObj = reference.Value(); if (!flag || runtimeHierarchyObj is RuntimeGroupLeafObj) { ((RuntimeGroupLeafObj)runtimeHierarchyObj).TraverseAllLeafNodes(ProcessingStages.RunningValues, aggContext); flag = false; } } } } }
public static bool UpdateAggregatesAtScope(AggregateUpdateContext aggContext, IDataRowHolder scope, DataScopeInfo scopeInfo, AggregateUpdateFlags updateFlags, bool needsSetupEnvironment) { return(aggContext.UpdateAggregates(scopeInfo, scope, updateFlags, needsSetupEnvironment)); }
protected virtual void CalculateRunningValuesForTopLevelStaticContents(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext) { }
public abstract void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext);
public abstract void UpdateAggregates(AggregateUpdateContext context);
public void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext) { for (int i = 0; i < this.m_dataRegionObjs.Count; i++) { RuntimeDataRegionObjReference runtimeDataRegionObjReference = this.m_dataRegionObjs[i]; if ((BaseReference)runtimeDataRegionObjReference != (object)null) { using (runtimeDataRegionObjReference.PinValue()) { runtimeDataRegionObjReference.Value().CalculateRunningValues(groupCollection, lastGroup, aggContext); } } } }
public abstract bool SortAndFilter(AggregateUpdateContext aggContext);
public void UpdateAggregates(AggregateUpdateContext aggContext) { this.Traverse(ProcessingStages.UpdateAggregates, aggContext); }
protected override void CalculateRunningValuesForTopLevelStaticContents(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext) { if (this.m_dataRegionScopedItems != null) { this.m_dataRegionScopedItems.CalculateRunningValues(groupCol, lastGroup, aggContext); } }
public void SortAndFilter(AggregateUpdateContext aggContext) { this.Traverse(ProcessingStages.SortAndFilter, aggContext); }
public override bool SortAndFilter(AggregateUpdateContext aggContext) { this.Traverse(ProcessingStages.SortAndFilter, aggContext); return(true); }
public override void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext) { Global.Tracer.Assert(false); }