private void SetValue(int index, T value, bool fromAdd)
{
CheckIndex(index, m_count - 1);
if (m_array != null)
{
using (m_array.PinValue())
{
m_array.Value().Array[index] = value;
if (fromAdd)
{
m_array.UpdateSize(ItemSizes.SizeOfInObjectArray(value));
}
}
}
else
{
IReference <StorableArray> reference = m_buckets[GetBucketIndex(index)];
using (reference.PinValue())
{
reference.Value().Array[GetIndexInBucket(index)] = value;
if (fromAdd)
{
reference.UpdateSize(ItemSizes.SizeOfInObjectArray(value));
}
}
}
m_version++;
}
public RuntimeCell GetAndPinCell(int key, out IDisposable cleanupRef)
{
cleanupRef = null;
IStorable storable = default(IStorable);
bool flag;
if (key < this.m_collection.Count)
{
cleanupRef = this.m_collection.GetAndPin(key, out storable);
flag = (storable != null);
}
else
{
storable = null;
flag = false;
}
if (flag)
{
if (this.IsCellReference(storable))
{
if (cleanupRef != null)
{
cleanupRef.Dispose();
}
IReference <RuntimeCell> reference = (IReference <RuntimeCell>)storable;
reference.PinValue();
cleanupRef = (IDisposable)reference;
return(reference.Value());
}
return((RuntimeCell)storable);
}
return(null);
}
internal static IOnDemandScopeInstance GetCellInstance(IReference <IOnDemandMemberInstance> outerGroupLeafRef, IReference <IOnDemandMemberInstance> innerGroupLeafRef, out IReference <IOnDemandScopeInstance> cellRef)
{
using (innerGroupLeafRef.PinValue())
{
return(innerGroupLeafRef.Value().GetCellInstance((IOnDemandMemberInstanceReference)outerGroupLeafRef, out cellRef));
}
}
public T this[int index]
{
get
{
CheckIndex(index, m_count - 1);
if (m_array != null)
{
using (m_array.PinValue())
{
return((T)m_array.Value().Array[index]);
}
}
IReference <StorableArray> reference = m_buckets[GetBucketIndex(index)];
using (reference.PinValue())
{
StorableArray bucket = reference.Value();
return(GetValueAt(index, bucket));
}
}
set
{
CheckReadOnly("set value");
SetValue(index, value, fromAdd: false);
}
}
public bool Remove(T item)
{
CheckReadOnly("Remove");
EqualityComparer <T> @default = EqualityComparer <T> .Default;
if (m_array != null)
{
using (m_array.PinValue())
{
object[] array = m_array.Value().Array;
return(Remove(item, 0, array, m_count, @default));
}
}
bool flag = false;
int count = m_buckets.Count;
for (int i = 0; i < count; i++)
{
if (flag)
{
break;
}
IReference <StorableArray> reference = m_buckets[i];
using (reference.PinValue())
{
int limit = (i != count - 1) ? m_bucketSize : (m_count - i * m_bucketSize);
object[] array2 = reference.Value().Array;
flag = Remove(item, i * m_bucketSize, array2, limit, @default);
}
}
return(flag);
}
private IDisposable SetAndPin(int index, T item, bool fromAdd)
{
CheckIndex(index, m_count - 1);
IDisposable result;
if (m_array != null)
{
result = m_array.PinValue();
m_array.Value().Array[index] = item;
if (fromAdd)
{
m_array.UpdateSize(ItemSizes.SizeOfInObjectArray(item));
}
}
else
{
int bucketIndex = GetBucketIndex(index);
IReference <StorableArray> reference = m_buckets[bucketIndex];
UnPinCascadeHolder unPinCascadeHolder = new UnPinCascadeHolder();
unPinCascadeHolder.AddCleanupRef(reference.PinValue());
m_buckets.PinContainingBucket(bucketIndex, unPinCascadeHolder);
result = unPinCascadeHolder;
reference.Value().Array[GetIndexInBucket(index)] = item;
if (fromAdd)
{
reference.UpdateSize(ItemSizes.SizeOfInObjectArray(item));
}
}
return(result);
}
public void RegisterActiveParent(IReference <IOnDemandScopeInstance> parentScopeInstanceRef)
{
using (parentScopeInstanceRef.PinValue())
{
parentScopeInstanceRef.Value().SetupEnvironment();
m_lastPrimaryKeyValues = m_activeRelationship.EvaluateJoinConditionKeys(evaluatePrimaryKeys: true, m_odpContext.ReportRuntime);
UpdateActiveParent(parentScopeInstanceRef);
}
}
public void RegisterActiveParent(IReference <IOnDemandScopeInstance> parentScopeInstanceRef)
{
using (parentScopeInstanceRef.PinValue())
{
IOnDemandScopeInstance onDemandScopeInstance = parentScopeInstanceRef.Value();
onDemandScopeInstance.SetupEnvironment();
this.m_lastPrimaryKeyValues = this.m_activeRelationship.EvaluateJoinConditionKeys(true, base.m_odpContext.ReportRuntime);
this.UpdateActiveParent(parentScopeInstanceRef);
}
}
internal override void CreateInstances(IReference <RuntimeDataRegionObj> containingScopeRef, OnDemandProcessingContext odpContext, DataRegionInstance dataRegionInstance, bool isOuterGrouping, IReference <RuntimeDataTablixGroupRootObj> currOuterGroupRoot, ScopeInstance parentInstance, IReference <RuntimeMemberObj>[] innerMembers, IReference <RuntimeDataTablixGroupLeafObj> innerGroupLeaf)
{
Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef = dataRegionInstance.DataRegionDef;
if (isOuterGrouping && m_hasStaticMembers)
{
dataRegionDef.NewOuterCells();
}
if (null != m_groupRoot)
{
dataRegionDef.CurrentOuterGroupRoot = currOuterGroupRoot;
using (m_groupRoot.PinValue())
{
m_groupRoot.Value().CreateInstances(parentInstance, innerMembers, innerGroupLeaf);
}
if (m_staticLeafCellIndexes == null)
{
return;
}
if (isOuterGrouping && m_hasStaticMembers)
{
dataRegionDef.NewOuterCells();
}
IReference <RuntimeDataTablixGroupRootObj> reference = null;
if (m_owner is IReference <RuntimeDataTablixObj> )
{
using (m_owner.PinValue())
{
((RuntimeDataTablixObj)m_owner.Value()).SetupEnvironment();
}
if (isOuterGrouping && m_hasStaticMembers)
{
reference = dataRegionDef.CurrentOuterGroupRoot;
dataRegionDef.CurrentOuterGroupRoot = null;
currOuterGroupRoot = null;
}
}
else
{
using (containingScopeRef.PinValue())
{
containingScopeRef.Value().SetupEnvironment();
}
}
CreateCells(containingScopeRef, odpContext, dataRegionInstance, isOuterGrouping, currOuterGroupRoot, parentInstance, innerMembers, innerGroupLeaf);
if (reference != null)
{
dataRegionDef.CurrentOuterGroupRoot = reference;
}
}
else
{
CreateCells(containingScopeRef, odpContext, dataRegionInstance, isOuterGrouping, currOuterGroupRoot, parentInstance, innerMembers, innerGroupLeaf);
}
}
internal override void InstanceComplete()
{
if (m_reportInstance != null)
{
m_reportInstance.Value()?.InstanceComplete();
}
IReference <SubReportInstance> obj = (IReference <SubReportInstance>)m_cleanupRef;
base.InstanceComplete();
obj.PinValue();
}
internal override void CalculatePreviousAggregates()
{
if (m_previousValuesInGroup != null)
{
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < m_previousValuesInGroup.Count; i++)
{
string text = m_previousValuesInGroup[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected previous aggregate: {0}", text);
aggregateObj.Update();
}
}
if (m_outerScope != null && (m_outerDataAction & DataActions.PostSortAggregates) != 0)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().CalculatePreviousAggregates();
}
}
}
private void ProcessInnerHierarchy(AggregateRowInfo aggregateRowInfo)
{
for (int i = 0; i < m_innerGroupings.Length; i++)
{
IReference <RuntimeMemberObj> reference = m_innerGroupings[i];
using (reference.PinValue())
{
reference.Value().NextRow(isOuterGrouping: false, m_odpContext);
}
aggregateRowInfo.RestoreAggregateInfo(m_odpContext);
}
}
protected void ProcessDetailSort()
{
if (m_detailUserSortTargetInfo != null && !m_detailUserSortTargetInfo.TargetForNonDetailSort)
{
IReference <RuntimeSortFilterEventInfo> reference = m_odpContext.RuntimeSortFilterInfo[m_detailUserSortTargetInfo.SortFilterInfoIndices[0]];
object sortOrder;
using (reference.PinValue())
{
sortOrder = reference.Value().GetSortOrder(m_odpContext.ReportRuntime);
}
m_detailUserSortTargetInfo.SortTree.NextRow(sortOrder, this);
}
}
public void AddSortInfoIndex(int sortInfoIndex, IReference <RuntimeSortFilterEventInfo> sortInfoRef)
{
using (sortInfoRef.PinValue())
{
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = sortInfoRef.Value();
Global.Tracer.Assert(runtimeSortFilterEventInfo.EventSource.UserSort.SortExpressionScope == null || !runtimeSortFilterEventInfo.TargetSortFilterInfoAdded);
if (this.m_sortFilterInfoIndices == null)
{
this.m_sortFilterInfoIndices = new List <int>();
}
this.m_sortFilterInfoIndices.Add(sortInfoIndex);
runtimeSortFilterEventInfo.TargetSortFilterInfoAdded = true;
}
}
private void ProcessOuterHierarchy(AggregateRowInfo aggregateRowInfo, int outerGroupingIndex)
{
m_odpContext.PeerOuterGroupProcessing = (outerGroupingIndex != 0);
m_dataRegionDef.ResetOuterGroupingIndexesForOuterPeerGroup(0);
m_dataRegionDef.ResetOuterGroupingAggregateRowInfo();
m_dataRegionDef.SetDataTablixAggregateRowInfo(aggregateRowInfo);
IReference <RuntimeMemberObj> reference = m_outerGroupings[outerGroupingIndex];
using (reference.PinValue())
{
reference.Value().NextRow(isOuterGrouping: true, m_odpContext);
}
aggregateRowInfo.RestoreAggregateInfo(m_odpContext);
}
public void ProcessUserSortForTarget(ObjectModelImpl reportObjectModel, AspNetCore.ReportingServices.RdlExpressions.ReportRuntime reportRuntime, IReference <IHierarchyObj> target, ref ScalableList <DataFieldRow> dataRows, bool targetForNonDetailSort)
{
using (target.PinValue())
{
IHierarchyObj hierarchyObj = target.Value();
if (targetForNonDetailSort && dataRows != null && 0 < dataRows.Count)
{
IReference <RuntimeSortFilterEventInfo> reference = null;
try
{
List <int> sortFilterInfoIndices = hierarchyObj.SortFilterInfoIndices;
Global.Tracer.Assert(null != hierarchyObj.SortTree, "(null != targetObj.SortTree)");
if (sortFilterInfoIndices != null)
{
reference = this.m_runtimeSortFilterInfo[sortFilterInfoIndices[0]];
}
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = null;
if (reference != null)
{
reference.PinValue();
runtimeSortFilterEventInfo = reference.Value();
}
for (int i = 0; i < dataRows.Count; i++)
{
dataRows[i].SetFields(reportObjectModel.FieldsImpl);
object keyValue = DBNull.Value;
if (runtimeSortFilterEventInfo != null)
{
keyValue = runtimeSortFilterEventInfo.GetSortOrder(reportRuntime);
}
hierarchyObj.SortTree.NextRow(keyValue, hierarchyObj);
}
}
finally
{
if (reference != null)
{
reference.UnPinValue();
}
}
if (dataRows != null)
{
dataRows.Dispose();
}
dataRows = null;
}
hierarchyObj.MarkSortInfoProcessed(this.m_runtimeSortFilterInfo);
}
}
internal void RemoveDomainScopes(IReference <RuntimeMemberObj>[] membersDef, int startIndex)
{
for (int i = startIndex; i < membersDef.Length; i++)
{
IReference <RuntimeMemberObj> reference = membersDef[i];
using (reference.PinValue())
{
IReference <RuntimeGroupRootObj> groupRoot = ((RuntimeDataTablixMemberObj)reference.Value()).GroupRoot;
using (groupRoot.PinValue())
{
m_domainScopes.Remove(groupRoot.Value().HierarchyDef.OriginalScopeID);
}
}
}
}
void IHierarchyObj.NextRow(IHierarchyObj owner)
{
if (m_dataHolder != null)
{
using (m_dataHolder.PinValue())
{
m_dataHolder.Value().NextRow();
}
}
else if (m_sortHierarchyStruct != null)
{
IReference <RuntimeSortFilterEventInfo> sortInfo = m_sortHierarchyStruct.SortInfo;
object sortOrder;
using (sortInfo.PinValue())
{
sortOrder = sortInfo.Value().GetSortOrder(m_odpContext.ReportRuntime);
}
m_sortHierarchyStruct.SortTree.NextRow(sortOrder, this);
}
else if (m_dataRowHolder != null)
{
m_dataRowHolder.NextRow(m_odpContext, Depth + 1);
}
}
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)runtimeDataRegionObj).CreateStaticCells(dataRegionInstance, parentInstance, currOuterGroupRoot, isOuterGroup, m_staticLeafCellIndexes, innerMembers, innerGroupLeafRef);
}
else
{
((RuntimeDataTablixObj)runtimeDataRegionObj).CreateOutermostStaticCells(dataRegionInstance, isOuterGroup, innerMembers, innerGroupLeafRef);
}
}
}
public override void InstanceComplete()
{
if (this.m_reportInstance != null)
{
ReportInstance reportInstance = this.m_reportInstance.Value();
if (reportInstance != null)
{
reportInstance.InstanceComplete();
}
}
IReference <SubReportInstance> reference = (IReference <SubReportInstance>)base.m_cleanupRef;
base.InstanceComplete();
reference.PinValue();
}
internal override void NextRow(object keyValue, bool hasParent, object parentKey)
{
if (m_lastChild != null && m_owner.OdpContext.EqualityComparer.Equals(m_lastValue, keyValue))
{
using (m_lastChild.PinValue())
{
m_lastChild.Value().NextRow();
}
}
else
{
m_lastValue = keyValue;
m_lastChild = CreateHierarchyObjAndAddToParent();
}
}
public static void AddRunningValues(OnDemandProcessingContext odpContext, List <AspNetCore.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, ref List <string> runningValuesInGroup, ref List <string> previousValuesInGroup, Dictionary <string, IReference <RuntimeGroupRootObj> > groupCollection, IReference <RuntimeGroupRootObj> lastGroup)
{
if (runningValues != null && 0 < runningValues.Count)
{
if (runningValuesInGroup == null)
{
runningValuesInGroup = new List <string>();
}
if (previousValuesInGroup == null)
{
previousValuesInGroup = new List <string>();
}
AggregatesImpl aggregatesImpl = odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < runningValues.Count; i++)
{
AspNetCore.ReportingServices.ReportIntermediateFormat.RunningValueInfo runningValueInfo = runningValues[i];
AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj dataAggregateObj = aggregatesImpl.GetAggregateObj(runningValueInfo.Name);
if (dataAggregateObj == null)
{
dataAggregateObj = new AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObj(runningValueInfo, odpContext);
aggregatesImpl.Add(dataAggregateObj);
}
if (runningValueInfo.Scope != null)
{
IReference <RuntimeGroupRootObj> reference = default(IReference <RuntimeGroupRootObj>);
if (groupCollection.TryGetValue(runningValueInfo.Scope, out reference))
{
using (reference.PinValue())
{
reference.Value().AddScopedRunningValue(dataAggregateObj);
}
}
else
{
Global.Tracer.Assert(false);
}
}
if (runningValueInfo.AggregateType == AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo.AggregateTypes.Previous)
{
previousValuesInGroup.Add(dataAggregateObj.Name);
}
else
{
runningValuesInGroup.Add(dataAggregateObj.Name);
}
}
}
}
private void MarkSortInfoProcessed(List <IReference <RuntimeSortFilterEventInfo> > runtimeSortFilterInfo, IReference <IHierarchyObj> sortTarget, ICollection indices)
{
foreach (int index in indices)
{
IReference <RuntimeSortFilterEventInfo> reference = runtimeSortFilterInfo[index];
using (reference.PinValue())
{
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = reference.Value();
if (runtimeSortFilterEventInfo.EventTarget.Equals(sortTarget))
{
Global.Tracer.Assert(!runtimeSortFilterEventInfo.Processed, "(!runtimeSortInfo.Processed)");
runtimeSortFilterEventInfo.Processed = true;
}
}
}
}
public IDisposable GetAndPin(int index, out T item)
{
this.CheckIndex(index, this.m_count - 1);
if (this.m_array != null)
{
this.m_array.PinValue();
item = (T)this.m_array.Value().Array[index];
return((IDisposable)this.m_array);
}
IReference <StorableArray> reference = this.m_buckets[this.GetBucketIndex(index)];
reference.PinValue();
StorableArray bucket = reference.Value();
item = this.GetValueAt(index, bucket);
return((IDisposable)reference);
}
private RuntimeCell GetOrCreateCellByIndex(int groupLeafIndex, Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, IReference<RuntimeDataTablixGroupLeafObj> ownerRef, RuntimeDataTablixGroupRootObj currOuterGroupRoot, out IDisposable cleanupRef)
{
RuntimeCell andPinCell = GetAndPinCell(groupLeafIndex, out cleanupRef);
if (andPinCell == null)
{
using (ownerRef.PinValue())
{
RuntimeDataTablixGroupLeafObj runtimeDataTablixGroupLeafObj = ownerRef.Value();
if (!RuntimeCell.HasOnlySimpleGroupTreeCells(currOuterGroupRoot.HierarchyDef, runtimeDataTablixGroupLeafObj.MemberDef, dataRegionDef))
{
runtimeDataTablixGroupLeafObj.CreateCell(this, groupLeafIndex, currOuterGroupRoot.HierarchyDef, runtimeDataTablixGroupLeafObj.MemberDef, dataRegionDef);
}
}
andPinCell = GetAndPinCell(groupLeafIndex, out cleanupRef);
}
return andPinCell;
}
public int IndexOf(T item)
{
EqualityComparer <T> @default = EqualityComparer <T> .Default;
if (this.m_array != null)
{
object[] array = this.m_array.Value().Array;
for (int i = 0; i < this.m_count; i++)
{
if (@default.Equals(item, (T)array[i]))
{
return(i);
}
}
}
else
{
int count = this.m_buckets.Count;
for (int j = 0; j < count; j++)
{
IReference <StorableArray> reference = this.m_buckets[j];
using (reference.PinValue())
{
object[] array2 = reference.Value().Array;
int num = 0;
if (j == count - 1)
{
num = this.m_count % this.m_bucketSize;
}
if (num == 0)
{
num = this.m_bucketSize;
}
for (int k = 0; k < num; k++)
{
if (@default.Equals(item, (T)array2[k]))
{
return(j * this.m_bucketSize + k);
}
}
}
}
}
return(-1);
}
private void ProcessParent(object parentKey, IReference <RuntimeGroupLeafObj> parentObj, RuntimeGroupLeafObjReference childObj, bool addToWaitList)
{
if (parentObj != null)
{
using (parentObj.PinValue())
{
parentObj.Value().AddChild(childObj);
}
}
else
{
RuntimeGroupRootObj runtimeGroupRootObj = base.m_owner as RuntimeGroupRootObj;
runtimeGroupRootObj.AddChild(childObj);
if (addToWaitList)
{
ChildLeafInfo childLeafInfo = null;
IDisposable disposable2 = null;
try
{
if (this.m_parentInfo == null)
{
this.m_parentInfo = this.CreateParentInfo();
}
else
{
this.m_parentInfo.TryGetAndPin(parentKey, out childLeafInfo, out disposable2);
}
if (childLeafInfo == null)
{
childLeafInfo = new ChildLeafInfo();
disposable2 = this.m_parentInfo.AddAndPin(parentKey, childLeafInfo);
}
childLeafInfo.Add(childObj);
}
finally
{
if (disposable2 != null)
{
disposable2.Dispose();
}
}
}
}
}
protected void DetailHandleSortFilterEvent(Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, IReference <IScope> outerScope, bool isColumnAxis, int rowIndex)
{
using (outerScope.PinValue())
{
IScope scope = outerScope.Value();
List <IReference <RuntimeSortFilterEventInfo> > runtimeSortFilterInfo = m_odpContext.RuntimeSortFilterInfo;
if (runtimeSortFilterInfo == null || dataRegionDef.SortFilterSourceDetailScopeInfo == null || scope.TargetForNonDetailSort)
{
return;
}
int count = runtimeSortFilterInfo.Count;
for (int i = 0; i < count; i++)
{
IReference <RuntimeSortFilterEventInfo> reference = runtimeSortFilterInfo[i];
using (reference.PinValue())
{
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = reference.Value();
if (runtimeSortFilterEventInfo.EventSource.ContainingScopes == null || 0 >= runtimeSortFilterEventInfo.EventSource.ContainingScopes.Count || -1 == dataRegionDef.SortFilterSourceDetailScopeInfo[i] || !scope.TargetScopeMatched(i, detailSort: false) || m_odpContext.ReportObjectModel.FieldsImpl.GetRowIndex() != dataRegionDef.SortFilterSourceDetailScopeInfo[i])
{
continue;
}
if (runtimeSortFilterEventInfo.EventSource.ContainingScopes.LastEntry == null)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ReportItem parent = runtimeSortFilterEventInfo.EventSource.Parent;
if (runtimeSortFilterEventInfo.EventSource.IsSubReportTopLevelScope)
{
while (parent != null && !(parent is Microsoft.ReportingServices.ReportIntermediateFormat.SubReport))
{
parent = parent.Parent;
}
Global.Tracer.Assert(parent is Microsoft.ReportingServices.ReportIntermediateFormat.SubReport, "(parent is SubReport)");
parent = parent.Parent;
}
if (parent == dataRegionDef)
{
runtimeSortFilterEventInfo.SetEventSourceScope(isColumnAxis, SelfReference, rowIndex);
}
}
runtimeSortFilterEventInfo.AddDetailScopeInfo(isColumnAxis, SelfReference, rowIndex);
}
}
}
}
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;
}
}
}
protected void DetailHandleSortFilterEvent(AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, IReference <IScope> outerScope, bool isColumnAxis, int rowIndex)
{
using (outerScope.PinValue())
{
IScope scope = outerScope.Value();
List <IReference <RuntimeSortFilterEventInfo> > runtimeSortFilterInfo = this.m_odpContext.RuntimeSortFilterInfo;
if (runtimeSortFilterInfo != null && dataRegionDef.SortFilterSourceDetailScopeInfo != null && !scope.TargetForNonDetailSort)
{
int count = runtimeSortFilterInfo.Count;
for (int i = 0; i < count; i++)
{
IReference <RuntimeSortFilterEventInfo> reference = runtimeSortFilterInfo[i];
using (reference.PinValue())
{
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = reference.Value();
if (runtimeSortFilterEventInfo.EventSource.ContainingScopes != null && 0 < runtimeSortFilterEventInfo.EventSource.ContainingScopes.Count && -1 != dataRegionDef.SortFilterSourceDetailScopeInfo[i] && scope.TargetScopeMatched(i, false) && this.m_odpContext.ReportObjectModel.FieldsImpl.GetRowIndex() == dataRegionDef.SortFilterSourceDetailScopeInfo[i])
{
if (runtimeSortFilterEventInfo.EventSource.ContainingScopes.LastEntry == null)
{
AspNetCore.ReportingServices.ReportIntermediateFormat.ReportItem parent = runtimeSortFilterEventInfo.EventSource.Parent;
if (runtimeSortFilterEventInfo.EventSource.IsSubReportTopLevelScope)
{
while (parent != null && !(parent is AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport))
{
parent = parent.Parent;
}
Global.Tracer.Assert(parent is AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport, "(parent is SubReport)");
parent = parent.Parent;
}
if (parent == dataRegionDef)
{
runtimeSortFilterEventInfo.SetEventSourceScope(isColumnAxis, this.SelfReference, rowIndex);
}
}
runtimeSortFilterEventInfo.AddDetailScopeInfo(isColumnAxis, this.SelfReference, rowIndex);
}
}
}
}
}
}
