void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
SortAndFilter((AggregateUpdateContext)traversalContext);
break;
case ProcessingStages.RunningValues:
CalculateRunningValues((AggregateUpdateContext)traversalContext);
break;
case ProcessingStages.CreateGroupTree:
CreateInstances((CreateInstancesTraversalContext)traversalContext);
break;
case ProcessingStages.UpdateAggregates:
UpdateAggregates((AggregateUpdateContext)traversalContext);
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
public override void Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (this.m_hierarchyNode != null)
{
this.m_hierarchyNode.Traverse(operation, traversalContext);
}
}
void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (this.m_sortHierarchyStruct != null)
{
bool ascending = true;
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = this.m_sortHierarchyStruct.SortInfo.Value();
if (runtimeSortFilterEventInfo.EventSource.UserSort.SortExpressionScope == null)
{
ascending = runtimeSortFilterEventInfo.SortDirection;
}
this.m_sortHierarchyStruct.SortTree.Traverse(operation, ascending, traversalContext);
}
if (this.m_dataHolder != null)
{
using (this.m_dataHolder.PinValue())
{
this.m_dataHolder.Value().Traverse(operation, traversalContext);
}
}
if (this.m_dataRowHolder != null)
{
using (this.m_hierarchyRoot.PinValue())
{
this.m_dataRowHolder.Traverse(operation, traversalContext, this.m_hierarchyRoot.Value());
}
}
}
internal override void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
RuntimeGroupRootObj runtimeGroupRootObj = m_owner as RuntimeGroupRootObj;
Global.Tracer.Assert(runtimeGroupRootObj != null, "(null != groupRootOwner)");
runtimeGroupRootObj.TraverseLinkedGroupLeaves(operation, ascending, traversalContext);
}
internal override void Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (m_hierarchyNode != null)
{
m_hierarchyNode.Traverse(operation, traversalContext);
}
}
public override void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
RuntimeGroupRootObj runtimeGroupRootObj = base.m_owner as RuntimeGroupRootObj;
Global.Tracer.Assert(null != runtimeGroupRootObj, "(null != groupRootOwner)");
runtimeGroupRootObj.GroupOrDetailSortTree.Traverse(operation, ascending, traversalContext);
}
protected override void Traverse(ProcessingStages operation, ITraversalContext context)
{
base.Traverse(operation, context);
if (this.m_dataRegionScopedItems != null)
{
this.TraverseDataRegionScopedItems(operation, context);
}
}
public void ReadRows(DataActions action, ITraversalContext context)
{
for (int i = 0; i < m_dataRows.Count; i++)
{
m_dataRows[i].SetFields(m_odpContext.ReportObjectModel.FieldsImpl);
ReadRow(action, context);
}
}
public void ReadRows(DataActions action, ITraversalContext context)
{
for (int i = 0; i < this.m_dataRows.Count; i++)
{
DataFieldRow dataFieldRow = this.m_dataRows[i];
dataFieldRow.SetFields(base.m_odpContext.ReportObjectModel.FieldsImpl);
this.ReadRow(action, context);
}
}
protected void TraverseGroupOrSortTree(ProcessingStages operation, ITraversalContext traversalContext)
{
if (m_detailUserSortTargetInfo != null && m_groupingType != 0)
{
m_detailUserSortTargetInfo.SortTree.Traverse(operation, GetDetailSortDirection(), traversalContext);
}
else
{
m_grouping.Traverse(operation, m_expression == null || m_expression.Direction, traversalContext);
}
}
void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (this.m_dataRowHolder != null)
{
this.m_dataRowHolder.Traverse(operation, traversalContext, this);
}
else
{
this.m_sortTree.Traverse(operation, this.m_sortExpression.Direction, traversalContext);
}
}
public void Traverse(ProcessingStages operation, ITraversalContext traversalContext, IHierarchyObj owner)
{
Global.Tracer.Assert(ProcessingStages.UserSortFilter == operation || owner.InDataRowSortPhase, "Invalid call to RuntimeSortDataHolder.Traverse. Must be in UserSortFilter stage or InDataRowSortPhase");
if (this.m_firstRow != null)
{
DataRowSortOwnerTraversalContext context = traversalContext as DataRowSortOwnerTraversalContext;
this.Traverse(this.m_firstRow, operation, context, owner);
if (this.m_dataRows != null)
{
for (int i = 0; i < this.m_dataRows.Count; i++)
{
this.Traverse(this.m_dataRows[i], operation, context, owner);
}
}
}
}
private void TraverseDataRegionScopedItems(ProcessingStages operation, ITraversalContext context)
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
this.m_dataRegionScopedItems.SortAndFilter((AggregateUpdateContext)context);
break;
case ProcessingStages.UpdateAggregates:
this.m_dataRegionScopedItems.UpdateAggregates((AggregateUpdateContext)context);
break;
default:
Global.Tracer.Assert(false, "Unknown ProcessingStage for TraverseDataRegionScopedItems");
break;
}
}
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 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);
}
protected virtual void Traverse(ProcessingStages operation, ITraversalContext context)
{
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;
if (array != null)
{
for (int i = 0; i < array.Length; i++)
{
TraverseMember(array[i], operation, context);
}
}
if (array2 != null)
{
for (int j = 0; j < array2.Length; j++)
{
TraverseMember(array2[j], operation, context);
}
}
}
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);
}
}
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (DataActions.UserSort == dataAction)
{
RuntimeDataRegionObj.CommonFirstRow(m_odpContext, ref m_firstRowIsAggregate, ref m_firstRow);
CommonNextRow(m_dataRows);
return;
}
if (DataActions.AggregatesOfAggregates == dataAction)
{
((AggregateUpdateContext)context).UpdateAggregatesForRow();
return;
}
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregatesOfAggregates))
{
((AggregateUpdateContext)context).UpdateAggregatesForRow();
}
if (m_dataRegionDef.ProcessCellRunningValues)
{
return;
}
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregates))
{
if (m_postSortAggregates != null)
{
RuntimeDataRegionObj.UpdateAggregates(m_odpContext, m_postSortAggregates, updateAndSetup: false);
}
if (m_runningValues != null)
{
UpdateRunningValues(m_odpContext, m_runningValues);
}
}
if (m_outerScope != null && (dataAction & m_outerDataAction) != 0)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().ReadRow(dataAction, context);
}
}
}
public abstract void ReadRow(DataActions dataAction, ITraversalContext context);
private void TraverseMember(IReference <RuntimeMemberObj> memberRef, ProcessingStages operation, ITraversalContext context)
{
using (memberRef.PinValue())
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
memberRef.Value().SortAndFilter((AggregateUpdateContext)context);
break;
case ProcessingStages.UpdateAggregates:
memberRef.Value().UpdateAggregates((AggregateUpdateContext)context);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown ProcessingStage in TraverseMember");
break;
}
}
}
internal abstract void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext);
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
Global.Tracer.Assert(condition: false);
}
void IScope.ReadRow(DataActions dataAction, ITraversalContext context)
{
Global.Tracer.Assert(false);
}
internal void TraverseLinkedGroupLeaves(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
if (null != m_firstChild)
{
using (m_firstChild.PinValue())
{
m_firstChild.Value().TraverseAllLeafNodes(operation, traversalContext);
}
}
}
public abstract void Traverse(ProcessingStages operation, ITraversalContext traversalContext);
public void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
this.m_root.Traverse(operation, ascending, this.m_nodes, traversalContext);
}
void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
Global.Tracer.Assert(condition: false);
}
public override void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
this.m_tree.Traverse(operation, ascending, traversalContext);
}
internal void Traverse(ProcessingStages operation, bool ascending, ITraversalContext traversalContext)
{
m_root.Traverse(operation, ascending, m_nodes, traversalContext);
}
internal void Traverse(ProcessingStages operation, bool ascending, ScalableList <BTreeNode> nodes, ITraversalContext traversalContext)
{
if (ascending)
{
for (int i = 0; i < m_tuples.Count; i++)
{
m_tuples[i].Traverse(operation, ascending, nodes, traversalContext);
}
return;
}
for (int num = m_tuples.Count - 1; num >= 0; num--)
{
m_tuples[num].Traverse(operation, ascending, nodes, traversalContext);
}
}