internal Group(CustomReportItem owner, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode memberDef, DataRegionMember dataMember)
{
m_isOldSnapshot = false;
m_criOwner = owner;
m_memberDef = memberDef;
m_dataMember = dataMember;
}
internal RuntimeDataTablixGroupRootObj(IReference <IScope> outerScope, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode dynamicMember, ref DataActions dataAction, OnDemandProcessingContext odpContext, IReference <RuntimeMemberObj>[] innerGroupings, bool outermostStatics, int headingLevel, Microsoft.ReportingServices.ReportProcessing.ObjectType objectType)
: base(outerScope, dynamicMember, dataAction, odpContext, objectType)
{
m_innerGroupings = innerGroupings;
m_headingLevel = headingLevel;
m_outermostStatics = outermostStatics;
m_hasLeafCells = false;
HierarchyNodeList innerStaticMembersInSameScope = dynamicMember.InnerStaticMembersInSameScope;
m_hasLeafCells = (!dynamicMember.HasInnerDynamic || (innerStaticMembersInSameScope != null && innerStaticMembersInSameScope.LeafCellIndexes != null));
if (((innerGroupings == null && innerStaticMembersInSameScope != null && innerStaticMembersInSameScope.LeafCellIndexes != null) || (innerGroupings != null && outermostStatics)) && m_hasLeafCells)
{
m_processStaticCellsForRVs = true;
}
if (m_hasLeafCells && outermostStatics)
{
m_processOutermostStaticCells = true;
}
NeedProcessDataActions(dynamicMember);
NeedProcessDataActions(dynamicMember.InnerStaticMembersInSameScope);
if (dynamicMember.Grouping.Filters == null)
{
dataAction = DataActions.None;
}
if ((m_processOutermostStaticCells || m_processStaticCellsForRVs) && (dynamicMember.DataRegionDef.CellPostSortAggregates != null || dynamicMember.DataRegionDef.CellRunningValues != null))
{
m_dataAction |= DataActions.PostSortAggregates;
}
}
private void NeedProcessDataActions(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode memberDefinition)
{
if (memberDefinition != null)
{
NeedProcessDataActions(memberDefinition.RunningValues);
}
}
internal ScopeIDContext(ScopeID scopeID, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode memberDef, InternalStreamingOdpDynamicMemberLogic memberLogic, RestartMode restartMode)
: base(restartMode)
{
m_scopeID = scopeID;
m_memberDef = memberDef;
m_memberLogic = memberLogic;
}
private bool IsParentScopeIDAlreadySet(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode target)
{
if (m_queryRestartPosition.Count == 0)
{
return(!ParentScopeIsDynamic(target));
}
return(IsParentScopeAdded(target));
}
private void AddGroupScope(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode member, ref FunctionalList <ScopeTreeNode> axisScopes)
{
if (!m_scopes.TryGetValue(member, out ScopeTreeNode value))
{
value = (HasScope(axisScopes) ? new SubScopeNode(member, m_activeScopes.First) : new SubScopeNode(member, m_dataRegionScopes.First));
}
AddScope(value);
axisScopes = axisScopes.Add(value);
}
internal bool TryAddScopeID(ScopeID scopeID, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode memberDef, InternalStreamingOdpDynamicMemberLogic memberLogic)
{
if (IsParentScopeIDAlreadySet(memberDef))
{
RestartMode restartMode = (!CanMarkRestartable(memberDef)) ? RestartMode.Rom : RestartMode.Query;
m_queryRestartPosition.Add(new ScopeIDContext(scopeID, memberDef, memberLogic, restartMode));
return(true);
}
return(false);
}
internal void UnRegisterGrouping(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode member)
{
if (member.IsColumn)
{
RemoveGroupScope(ref m_activeColumnScopes);
}
else
{
RemoveGroupScope(ref m_activeRowScopes);
}
}
private bool CanMarkRestartable(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode memberDef)
{
if (memberDef.DataScopeInfo.IsDecomposable && memberDef.Sorting != null && memberDef.Sorting.NaturalSort)
{
if (LastScopeIDContext != null)
{
return(LastScopeIDContext.IsRowLevelRestart);
}
return(true);
}
return(false);
}
protected override void InitializeGroupScopedItems(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode member, ref DataActions innerDataAction)
{
List <Microsoft.ReportingServices.ReportIntermediateFormat.ReportItem> groupScopedContents = GetGroupScopedContents(member);
if (groupScopedContents != null)
{
if (m_groupScopedItems == null)
{
m_groupScopedItems = new RuntimeRICollection(groupScopedContents.Count);
}
m_groupScopedItems.AddItems(m_selfReference, groupScopedContents, ref innerDataAction, m_odpContext);
}
}
protected static IOnDemandMemberInstanceReference GetFirstMemberInstance(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember, IReference <RuntimeMemberObj>[] memberCol)
{
IOnDemandMemberInstanceReference result = null;
RuntimeDataTablixGroupRootObjReference groupRoot = GetGroupRoot(rifMember, memberCol);
using (groupRoot.PinValue())
{
RuntimeGroupLeafObjReference firstChild = groupRoot.Value().FirstChild;
if (firstChild != null)
{
return((IOnDemandMemberInstanceReference)firstChild);
}
return(result);
}
}
private IReference <RuntimeMemberObj>[] GetMemberCollection(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember)
{
if (m_dataRegionDef.ProcessingInnerGrouping == Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion.ProcessingInnerGroupings.Column)
{
if (rifMember.IsColumn)
{
return(m_innerGroupings);
}
return(m_outerGroupings);
}
if (rifMember.IsColumn)
{
return(m_outerGroupings);
}
return(m_innerGroupings);
}
private RuntimeDataTablixMemberObj(IReference <IScope> owner, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode dynamicMember, ref DataActions dataAction, OnDemandProcessingContext odpContext, IReference <RuntimeMemberObj>[] innerGroupings, HierarchyNodeList staticMembers, bool outerMostStatics, int headingLevel, Microsoft.ReportingServices.ReportProcessing.ObjectType objectType)
: base(owner, dynamicMember)
{
int excludedCellIndex = -1;
if (dynamicMember != null)
{
excludedCellIndex = dynamicMember.MemberCellIndex;
RuntimeDataTablixGroupRootObj runtimeDataTablixGroupRootObj = new RuntimeDataTablixGroupRootObj(owner, dynamicMember, ref dataAction, odpContext, innerGroupings, outerMostStatics, headingLevel, objectType);
m_groupRoot = (RuntimeDataTablixGroupRootObjReference)runtimeDataTablixGroupRootObj.SelfReference;
m_groupRoot.UnPinValue();
}
if (staticMembers != null && staticMembers.Count != 0)
{
_ = staticMembers.Count;
m_hasStaticMembers = true;
m_staticLeafCellIndexes = staticMembers.GetLeafCellIndexes(excludedCellIndex);
}
}
private bool IsParentScopeAdded(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode target)
{
if (target.DataScopeInfo.DataSet != LastScopeIDContext.MemberDefinition.DataScopeInfo.DataSet && !target.IsChildScopeOf(LastScopeIDContext.MemberDefinition) && !LastScopeIDContext.MemberDefinition.IsChildScopeOf(target))
{
return(true);
}
if (target.IsChildScopeOf(LastScopeIDContext.MemberDefinition))
{
return(true);
}
if (!target.DataScopeInfo.IsDecomposable)
{
for (int num = m_queryRestartPosition.Count - 2; num >= 0; num--)
{
if (target.IsChildScopeOf(m_queryRestartPosition[num].MemberDefinition))
{
return(true);
}
}
return(false);
}
return(false);
}
private void BindScopeToInstance(IRIFReportDataScope reportDataScope)
{
if (reportDataScope.IsBoundToStreamingScopeInstance)
{
return;
}
if (!reportDataScope.IsScope)
{
IRIFReportDataScope parentReportScope = reportDataScope.ParentReportScope;
EnsureScopeIsBound(parentReportScope);
reportDataScope.BindToStreamingScopeInstance(parentReportScope.CurrentStreamingScopeInstance);
return;
}
switch (reportDataScope.InstancePathItem.Type)
{
case InstancePathItemType.Cell:
if (reportDataScope.IsDataIntersectionScope)
{
IRIFReportIntersectionScope iRIFReportIntersectionScope = (IRIFReportIntersectionScope)reportDataScope;
IRIFReportDataScope parentRowReportScope = iRIFReportIntersectionScope.ParentRowReportScope;
if (!TryBindParentScope(reportDataScope, parentRowReportScope, out IReference <IOnDemandMemberInstance> parentScopeInst2))
{
break;
}
IRIFReportDataScope parentColumnReportScope = iRIFReportIntersectionScope.ParentColumnReportScope;
if (!TryBindParentScope(reportDataScope, parentColumnReportScope, out IReference <IOnDemandMemberInstance> parentScopeInst3))
{
break;
}
IReference <IOnDemandMemberInstance> reference;
IReference <IOnDemandMemberInstance> reference2;
if (!iRIFReportIntersectionScope.IsColumnOuterGrouping)
{
reference = parentScopeInst2;
reference2 = parentScopeInst3;
}
else
{
reference = parentScopeInst3;
reference2 = parentScopeInst2;
}
CheckForPrematureScopeInstance(reportDataScope);
IReference <IOnDemandScopeInstance> cellRef;
IOnDemandScopeInstance cellInstance = SyntheticTriangulatedCellReference.GetCellInstance(reference, reference2, out cellRef);
if (cellInstance == null && iRIFReportIntersectionScope.DataScopeInfo.NeedsIDC && TryProcessToCreateCell(iRIFReportIntersectionScope, (RuntimeDataTablixGroupLeafObjReference)reference2, (RuntimeDataTablixGroupLeafObjReference)reference))
{
cellInstance = SyntheticTriangulatedCellReference.GetCellInstance(reference, reference2, out cellRef);
}
if (cellInstance != null)
{
if (cellRef == null)
{
iRIFReportIntersectionScope.BindToStreamingScopeInstance(reference, reference2);
SetupEnvironment(reportDataScope, cellInstance, iRIFReportIntersectionScope.CurrentStreamingScopeInstance);
}
else
{
reportDataScope.BindToStreamingScopeInstance(cellRef);
}
}
}
else
{
Global.Tracer.Assert(condition: false, "Non-intersection cell scopes are not yet supported by streaming ODP.");
}
break;
case InstancePathItemType.ColumnMemberInstanceIndexTopMost:
case InstancePathItemType.ColumnMemberInstanceIndex:
case InstancePathItemType.RowMemberInstanceIndex:
{
IRIFReportDataScope parentReportScope3 = reportDataScope.ParentReportScope;
if (!TryBindParentScope(reportDataScope, parentReportScope3, out IReference <IOnDemandMemberOwnerInstance> parentScopeInst4))
{
break;
}
CheckForPrematureScopeInstance(reportDataScope);
using (parentScopeInst4.PinValue())
{
IOnDemandMemberOwnerInstance onDemandMemberOwnerInstance = parentScopeInst4.Value();
Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember = (Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode)reportDataScope;
IOnDemandMemberInstanceReference firstMemberInstance = onDemandMemberOwnerInstance.GetFirstMemberInstance(rifMember);
if (RequiresIdcProcessing(reportDataScope, firstMemberInstance, (IReference <IOnDemandScopeInstance>)parentScopeInst4))
{
firstMemberInstance = onDemandMemberOwnerInstance.GetFirstMemberInstance(rifMember);
}
reportDataScope.BindToStreamingScopeInstance(firstMemberInstance);
}
break;
}
case InstancePathItemType.DataRegion:
{
IRIFReportDataScope parentReportScope2 = reportDataScope.ParentReportScope;
Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegion = (Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion)reportDataScope;
if (parentReportScope2 == null)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataSet dataSet = dataRegion.DataScopeInfo.DataSet;
DataPipelineManager orCreatePipelineManager = GetOrCreatePipelineManager(dataSet, dataRegion);
reportDataScope.BindToStreamingScopeInstance(orCreatePipelineManager.GroupTreeRoot.GetDataRegionInstance(dataRegion));
}
else
{
if (!TryBindParentScope(reportDataScope, parentReportScope2, out IReference <IOnDemandScopeInstance> parentScopeInst))
{
break;
}
CheckForPrematureScopeInstance(reportDataScope);
using (parentScopeInst.PinValue())
{
IOnDemandScopeInstance onDemandScopeInstance = parentScopeInst.Value();
IReference <IOnDemandScopeInstance> dataRegionInstance = onDemandScopeInstance.GetDataRegionInstance(dataRegion);
if (RequiresIdcProcessing(reportDataScope, dataRegionInstance, parentScopeInst))
{
dataRegionInstance = onDemandScopeInstance.GetDataRegionInstance(dataRegion);
}
reportDataScope.BindToStreamingScopeInstance(dataRegionInstance);
}
}
break;
}
default:
Global.Tracer.Assert(false, "SetupObjectModels cannot handle IRIFReportDataScope of type: {0}", Enum.GetName(typeof(InstancePathItemType), reportDataScope.InstancePathItem.Type));
break;
}
}
protected override List <Microsoft.ReportingServices.ReportIntermediateFormat.ReportItem> GetGroupScopedContents(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode member)
{
return(((TablixMember)member).GroupScopedContentsForProcessing);
}
protected override RuntimeCell CreateCell(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode outerGroupingMember, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode innerGroupingMember)
{
return(new RuntimeTablixCell((RuntimeTablixGroupLeafObjReference)m_selfReference, (TablixMember)outerGroupingMember, (TablixMember)innerGroupingMember, !m_hasInnerHierarchy));
}
public IReference <IDataCorrelation> GetIdcReceiver(IRIFReportDataScope scope)
{
if (scope.IsGroup)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember = scope as Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode;
IReference <RuntimeMemberObj>[] memberCollection = GetMemberCollection(rifMember);
return(RuntimeDataRegionObj.GetGroupRoot(rifMember, memberCollection));
}
Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion rifDataRegion = scope as Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion;
return(GetNestedDataRegion(rifDataRegion));
}
internal RuntimeMemberObj(IReference <IScope> owner, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode dynamicMember)
{
m_owner = owner;
}
public IOnDemandMemberInstanceReference GetFirstMemberInstance(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember)
{
IReference <RuntimeMemberObj>[] memberCollection = GetMemberCollection(rifMember);
return(RuntimeDataRegionObj.GetFirstMemberInstance(rifMember, memberCollection));
}
protected RuntimeGroupRootObj(IReference <IScope> outerScope, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode hierarchyDef, DataActions dataAction, OnDemandProcessingContext odpContext, Microsoft.ReportingServices.ReportProcessing.ObjectType objectType)
: base(odpContext, objectType, outerScope.Value().Depth + 1)
{
m_hierarchyRoot = (RuntimeHierarchyObjReference)m_selfReference;
m_outerScope = outerScope;
m_hierarchyDef = hierarchyDef;
Microsoft.ReportingServices.ReportIntermediateFormat.Grouping grouping = hierarchyDef.Grouping;
Global.Tracer.Assert(grouping != null, "(null != groupDef)");
m_isDetailGroup = grouping.IsDetail;
if (m_isDetailGroup)
{
m_expression = null;
}
else
{
m_expression = new RuntimeExpressionInfo(grouping.GroupExpressions, grouping.ExprHost, grouping.SortDirections, 0);
}
if (m_odpContext.RuntimeSortFilterInfo != null)
{
int count = m_odpContext.RuntimeSortFilterInfo.Count;
using (outerScope.PinValue())
{
IScope scope = outerScope.Value();
for (int i = 0; i < count; i++)
{
IReference <RuntimeSortFilterEventInfo> reference = m_odpContext.RuntimeSortFilterInfo[i];
using (reference.PinValue())
{
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = reference.Value();
if (runtimeSortFilterEventInfo.EventSource.ContainingScopes != null && runtimeSortFilterEventInfo.EventSource.ContainingScopes.Count != 0 && !runtimeSortFilterEventInfo.HasEventSourceScope && (!m_isDetailGroup || !runtimeSortFilterEventInfo.EventSource.IsSubReportTopLevelScope))
{
continue;
}
bool flag = false;
if (m_isDetailGroup)
{
if (!scope.TargetForNonDetailSort && IsTargetForSort(i, detailSort: true) && runtimeSortFilterEventInfo.EventTarget != base.SelfReference && scope.TargetScopeMatched(i, detailSort: true))
{
flag = true;
if (m_detailUserSortTargetInfo == null)
{
m_detailUserSortTargetInfo = new RuntimeUserSortTargetInfo((IReference <IHierarchyObj>)base.SelfReference, i, reference);
}
else
{
m_detailUserSortTargetInfo.AddSortInfo((IReference <IHierarchyObj>)base.SelfReference, i, reference);
}
}
}
else if (grouping.IsSortFilterExpressionScope != null)
{
flag = (grouping.IsSortFilterExpressionScope[i] && m_odpContext.UserSortFilterContext.InProcessUserSortPhase(i) && TargetScopeMatched(i, detailSort: false));
}
if (flag)
{
if (m_builtinSortOverridden == null)
{
m_builtinSortOverridden = new bool[count];
}
m_builtinSortOverridden[i] = true;
}
}
}
}
}
if (m_detailUserSortTargetInfo != null)
{
m_groupingType = RuntimeGroupingObj.GroupingTypes.DetailUserSort;
}
else if (grouping.GroupAndSort && !BuiltinSortOverridden)
{
m_groupingType = RuntimeGroupingObj.GroupingTypes.Sort;
}
else if (grouping.IsDetail && grouping.Parent == null && !BuiltinSortOverridden)
{
m_groupingType = RuntimeGroupingObj.GroupingTypes.Detail;
}
else if (grouping.NaturalGroup)
{
m_groupingType = RuntimeGroupingObj.GroupingTypes.NaturalGroup;
}
else
{
m_groupingType = RuntimeGroupingObj.GroupingTypes.Hash;
}
m_grouping = RuntimeGroupingObj.CreateGroupingObj(m_groupingType, this, objectType);
if (grouping.Filters == null)
{
m_dataAction = dataAction;
m_outerDataAction = dataAction;
}
if (grouping.RecursiveAggregates != null)
{
m_dataAction |= DataActions.RecursiveAggregates;
}
if (grouping.PostSortAggregates != null)
{
m_dataAction |= DataActions.PostSortAggregates;
}
if (grouping.Parent != null)
{
m_parentExpression = new RuntimeExpressionInfo(grouping.Parent, grouping.ParentExprHost, null, 0);
}
}
internal RuntimeCellWithContents(RuntimeDataTablixGroupLeafObjReference owner, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode outerGroupingMember, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode innerGroupingMember, bool innermost)
: base(owner, outerGroupingMember, innerGroupingMember, innermost)
{
}
private void CreateTopLevelRuntimeGroupings(ref DataActions groupingDataAction, ref IReference <RuntimeMemberObj>[] groupings, HierarchyNodeList topLevelStaticMembers, HierarchyNodeList topLevelDynamicMembers, IReference <RuntimeMemberObj>[] innerGroupings, bool hasOppositeStaticLeafMembers)
{
int num = topLevelDynamicMembers?.Count ?? 0;
groupings = new IReference <RuntimeMemberObj> [Math.Max(1, num)];
if (num == 0)
{
IReference <RuntimeMemberObj> reference = RuntimeDataTablixMemberObj.CreateRuntimeMemberObject(m_selfReference, null, ref groupingDataAction, m_odpContext, innerGroupings, topLevelStaticMembers, hasOppositeStaticLeafMembers, 0, base.ObjectType);
groupings[0] = reference;
return;
}
for (int i = 0; i < num; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode dynamicMemberDef = topLevelDynamicMembers[i];
IReference <RuntimeMemberObj> reference2 = RuntimeDataTablixMemberObj.CreateRuntimeMemberObject(m_selfReference, dynamicMemberDef, ref groupingDataAction, m_odpContext, innerGroupings, (i == 0) ? topLevelStaticMembers : null, hasOppositeStaticLeafMembers, 0, base.ObjectType);
groupings[i] = reference2;
}
}
internal static IReference <RuntimeMemberObj> CreateRuntimeMemberObject(IReference <IScope> owner, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode dynamicMemberDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, IReference <RuntimeMemberObj>[] innerGroupings, HierarchyNodeList staticMembers, bool outerMostStatics, int headingLevel, Microsoft.ReportingServices.ReportProcessing.ObjectType dataRegionType)
{
RuntimeDataTablixMemberObj obj = new RuntimeDataTablixMemberObj(owner, dynamicMemberDef, ref dataAction, odpContext, innerGroupings, staticMembers, outerMostStatics, headingLevel, dataRegionType);
return(odpContext.TablixProcessingScalabilityCache.Allocate((RuntimeMemberObj)obj, headingLevel));
}
protected bool AddRunningValues(List <Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, ref List <string> runningValuesInGroup, ref List <string> previousValuesInGroup, Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection, bool cellRunningValues, bool outermostStatics)
{
bool result = false;
if (runningValues == null || 0 >= runningValues.Count)
{
return(result);
}
if (runningValuesInGroup == null)
{
runningValuesInGroup = new List <string>();
}
if (previousValuesInGroup == null)
{
previousValuesInGroup = new List <string>();
}
if (cellRunningValues)
{
List <int> list = null;
List <int> list2 = null;
Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef = m_hierarchyDef.DataRegionDef;
bool isColumn = m_hierarchyDef.IsColumn;
RuntimeDataTablixGroupRootObj runtimeDataTablixGroupRootObj = this as RuntimeDataTablixGroupRootObj;
if (outermostStatics && ((runtimeDataTablixGroupRootObj != null && runtimeDataTablixGroupRootObj.InnerGroupings != null) || dataRegionDef.CurrentOuterGroupRoot == null))
{
if (isColumn)
{
list2 = m_hierarchyDef.GetCellIndexes();
list = dataRegionDef.OutermostStaticRowIndexes;
}
else
{
list2 = dataRegionDef.OutermostStaticColumnIndexes;
list = m_hierarchyDef.GetCellIndexes();
}
}
else
{
Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode hierarchyDef = dataRegionDef.CurrentOuterGroupRoot.Value().HierarchyDef;
if (isColumn)
{
list2 = m_hierarchyDef.GetCellIndexes();
list = ((!outermostStatics) ? hierarchyDef.GetCellIndexes() : dataRegionDef.OutermostStaticRowIndexes);
}
else
{
list = m_hierarchyDef.GetCellIndexes();
list2 = ((!outermostStatics) ? hierarchyDef.GetCellIndexes() : dataRegionDef.OutermostStaticColumnIndexes);
}
}
if (list != null && list2 != null)
{
foreach (int item in list)
{
foreach (int item2 in list2)
{
Cell cell = dataRegionDef.Rows[item].Cells[item2];
if (cell.RunningValueIndexes != null)
{
result = true;
for (int i = 0; i < cell.RunningValueIndexes.Count; i++)
{
int index = cell.RunningValueIndexes[i];
AddRunningValue(runningValues[index], runningValuesInGroup, previousValuesInGroup, groupCollection);
}
}
}
}
}
}
else
{
result = true;
for (int j = 0; j < runningValues.Count; j++)
{
AddRunningValue(runningValues[j], runningValuesInGroup, previousValuesInGroup, groupCollection);
}
}
if (previousValuesInGroup.Count == 0)
{
previousValuesInGroup = null;
}
if (runningValuesInGroup.Count == 0)
{
runningValuesInGroup = null;
}
return(result);
}
protected static RuntimeDataTablixGroupRootObjReference GetGroupRoot(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember, IReference <RuntimeMemberObj>[] memberCol)
{
Global.Tracer.Assert(!rifMember.IsStatic, "Cannot GetGroupRoot of a static member");
return(memberCol[rifMember.IndexInCollection].Value().GroupRoot);
}
protected abstract List <Microsoft.ReportingServices.ReportIntermediateFormat.ReportItem> GetGroupScopedContents(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode member);
internal override void CreateCell(RuntimeCells cellsCollection, int collectionKey, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode outerGroupingMember, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode innerGroupingMember, Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef)
{
RuntimeCell runtimeCell = new RuntimeChartCriCell((RuntimeChartCriGroupLeafObjReference)m_selfReference, outerGroupingMember, innerGroupingMember, !m_hasInnerHierarchy);
if (runtimeCell.SelfReference == null)
{
cellsCollection.AddCell(collectionKey, runtimeCell);
return;
}
IReference <RuntimeCell> selfReference = runtimeCell.SelfReference;
selfReference.UnPinValue();
cellsCollection.AddCell(collectionKey, selfReference);
}
protected abstract RuntimeCell CreateCell(Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode outerGroupingMember, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode innerGroupingMember);
internal RuntimeChartCriCell(RuntimeChartCriGroupLeafObjReference owner, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode outerGroupingMember, Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode innerGroupingMember, bool innermost)
: base(owner, outerGroupingMember, innerGroupingMember, innermost)
{
}