public void AddSortInfo(IReference <IHierarchyObj> owner, int sortInfoIndex, IReference <RuntimeSortFilterEventInfo> sortInfo)
{
IInScopeEventSource eventSource = sortInfo.Value().EventSource;
if (eventSource.UserSort.SortExpressionScope != null || owner.Value().IsDetail)
{
if (eventSource.UserSort.SortExpressionScope == null)
{
this.AddSortInfoIndex(sortInfoIndex, sortInfo);
}
if (this.m_sortTree == null)
{
IHierarchyObj hierarchyObj = owner.Value();
this.m_sortTree = new BTree(hierarchyObj, hierarchyObj.OdpContext, hierarchyObj.Depth + 1);
}
}
if (eventSource.UserSort.SortExpressionScope != null)
{
if (this.m_targetForNonDetailSort == null)
{
this.m_targetForNonDetailSort = new Hashtable();
}
this.m_targetForNonDetailSort.Add(sortInfoIndex, null);
}
else
{
if (this.m_targetForDetailSort == null)
{
this.m_targetForDetailSort = new Hashtable();
}
this.m_targetForDetailSort.Add(sortInfoIndex, null);
}
}
internal virtual void AddChildScope(IReference <ScopeInstance> childRef, int indexInCollection)
{
switch (childRef.Value().ObjectType)
{
case Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.DataRegionInstance:
if (m_dataRegionInstances == null)
{
m_dataRegionInstances = new List <IReference <DataRegionInstance> >();
}
ListUtils.AdjustLength(m_dataRegionInstances, indexInCollection);
Global.Tracer.Assert(m_dataRegionInstances[indexInCollection] == null, "(null == m_dataRegionInstances[indexInCollection])");
m_dataRegionInstances[indexInCollection] = (childRef as IReference <DataRegionInstance>);
break;
case Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.SubReportInstance:
if (m_subReportInstances == null)
{
m_subReportInstances = new List <IReference <SubReportInstance> >();
}
ListUtils.AdjustLength(m_subReportInstances, indexInCollection);
Global.Tracer.Assert(m_subReportInstances[indexInCollection] == null, "(null == m_subReportInstances[indexInCollection])");
m_subReportInstances[indexInCollection] = (childRef as IReference <SubReportInstance>);
break;
default:
Global.Tracer.Assert(condition: false, childRef.Value().ToString());
break;
}
}
internal RuntimeSortHierarchyObj(IHierarchyObj outerHierarchy, int depth)
{
m_hierarchyRoot = outerHierarchy.HierarchyRoot;
m_odpContext = m_hierarchyRoot.Value().OdpContext;
List <int> sortFilterInfoIndices = m_hierarchyRoot.Value().SortFilterInfoIndices;
int num = outerHierarchy.ExpressionIndex + 1;
if (sortFilterInfoIndices == null || num >= sortFilterInfoIndices.Count)
{
RuntimeDataTablixGroupRootObjReference runtimeDataTablixGroupRootObjReference = m_hierarchyRoot as RuntimeDataTablixGroupRootObjReference;
if (null != runtimeDataTablixGroupRootObjReference)
{
using (runtimeDataTablixGroupRootObjReference.PinValue())
{
RuntimeDataTablixGroupRootObj runtimeDataTablixGroupRootObj = runtimeDataTablixGroupRootObjReference.Value();
m_dataHolder = (IReference <ISortDataHolder>)runtimeDataTablixGroupRootObj.CreateGroupLeaf();
if (!runtimeDataTablixGroupRootObj.HasParent)
{
runtimeDataTablixGroupRootObj.AddChildWithNoParent((RuntimeGroupLeafObjReference)m_dataHolder);
}
}
}
else
{
m_dataRowHolder = new RuntimeSortDataHolder();
}
}
else
{
m_sortHierarchyStruct = new SortHierarchyStructure(this, num, m_odpContext.RuntimeSortFilterInfo, sortFilterInfoIndices);
}
}
private void Traverse(ProcessingStages operation, AggregateUpdateContext aggContext)
{
if (m_grouping != null)
{
m_grouping.Traverse(ProcessingStages.SortAndFilter, ascending: true, aggContext);
}
if (m_hierarchyObjs == null)
{
return;
}
for (int i = 0; i < m_hierarchyObjs.Count; i++)
{
IReference <RuntimeHierarchyObj> reference = m_hierarchyObjs[i];
using (reference.PinValue())
{
switch (operation)
{
case ProcessingStages.SortAndFilter:
reference.Value().SortAndFilter(aggContext);
break;
case ProcessingStages.UpdateAggregates:
reference.Value().UpdateAggregates(aggContext);
break;
}
}
}
}
internal override void GetScopeValues(IReference<IHierarchyObj> targetScopeObj, List<object>[] scopeValues, ref int index)
{
if (targetScopeObj == null || this != targetScopeObj.Value())
{
m_outerScope.Value().GetScopeValues(targetScopeObj, scopeValues, ref index);
}
}
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 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);
}
}
}
}
}
}
}
internal override void EvaluateScopedFieldReference(string scopeName, int fieldIndex, ref Microsoft.ReportingServices.RdlExpressions.VariantResult result)
{
Global.Tracer.Assert(m_lastRIFObject != null, "The RIF object for the current scope should be present.");
try
{
if (!m_odpContext.ReportDefinition.MappingNameToDataSet.TryGetValue(scopeName, out Microsoft.ReportingServices.ReportIntermediateFormat.DataSet value))
{
throw new ReportProcessingException_NonExistingScopeReference(scopeName);
}
if (!TryGetNonStructuralIdcDataManager(value, out NonStructuralIdcDataManager nsIdcDataManager))
{
nsIdcDataManager = CreateNonStructuralIdcDataManager(scopeName, value);
}
if (nsIdcDataManager.SourceDataScope.CurrentStreamingScopeInstance != nsIdcDataManager.LastParentScopeInstance)
{
nsIdcDataManager.RegisterActiveParent(nsIdcDataManager.SourceDataScope.CurrentStreamingScopeInstance);
nsIdcDataManager.Advance();
}
else
{
nsIdcDataManager.SetupEnvironment();
}
m_odpContext.ReportRuntime.EvaluateSimpleFieldReference(fieldIndex, ref result);
}
finally
{
SetupEnvironment(m_lastRIFObject, m_lastOnDemandScopeInstance.Value(), m_lastOnDemandScopeInstance);
}
}
private IDisposable SetAndPin(int index, T item, bool fromAdd)
{
this.CheckIndex(index, this.m_count - 1);
IDisposable result;
if (this.m_array != null)
{
result = this.m_array.PinValue();
this.m_array.Value().Array[index] = item;
if (fromAdd)
{
this.m_array.UpdateSize(ItemSizes.SizeOfInObjectArray(item));
}
}
else
{
int bucketIndex = this.GetBucketIndex(index);
IReference <StorableArray> reference = this.m_buckets[bucketIndex];
UnPinCascadeHolder unPinCascadeHolder = new UnPinCascadeHolder();
unPinCascadeHolder.AddCleanupRef(reference.PinValue());
this.m_buckets.PinContainingBucket(bucketIndex, unPinCascadeHolder);
result = unPinCascadeHolder;
StorableArray storableArray = reference.Value();
storableArray.Array[this.GetIndexInBucket(index)] = item;
if (fromAdd)
{
reference.UpdateSize(ItemSizes.SizeOfInObjectArray(item));
}
}
return(result);
}
private void SetValue(int index, T value, bool fromAdd)
{
this.CheckIndex(index, this.m_count - 1);
if (this.m_array != null)
{
using (this.m_array.PinValue())
{
this.m_array.Value().Array[index] = value;
if (fromAdd)
{
this.m_array.UpdateSize(ItemSizes.SizeOfInObjectArray(value));
}
}
}
else
{
IReference <StorableArray> reference = this.m_buckets[this.GetBucketIndex(index)];
using (reference.PinValue())
{
StorableArray storableArray = reference.Value();
storableArray.Array[this.GetIndexInBucket(index)] = value;
if (fromAdd)
{
reference.UpdateSize(ItemSizes.SizeOfInObjectArray(value));
}
}
}
this.m_version++;
}
public T this[int index]
{
get
{
this.CheckIndex(index, this.m_count - 1);
if (this.m_array != null)
{
using (this.m_array.PinValue())
{
return((T)this.m_array.Value().Array[index]);
}
}
IReference <StorableArray> reference = this.m_buckets[this.GetBucketIndex(index)];
using (reference.PinValue())
{
StorableArray bucket = reference.Value();
return(this.GetValueAt(index, bucket));
}
}
set
{
this.CheckReadOnly("set value");
this.SetValue(index, value, false);
}
}
internal void CreateInstances(CreateInstancesTraversalContext traversalContext)
{
if (m_grouping != null)
{
m_grouping.Traverse(ProcessingStages.CreateGroupTree, m_expression == null || m_expression.Direction, traversalContext);
}
if (m_hierarchyObjs == null)
{
return;
}
bool flag = true;
for (int i = 0; i < m_hierarchyObjs.Count; i++)
{
IReference <RuntimeHierarchyObj> reference = m_hierarchyObjs[i];
using (reference.PinValue())
{
RuntimeHierarchyObj runtimeHierarchyObj = reference.Value();
if (!flag || runtimeHierarchyObj is RuntimeGroupLeafObj)
{
((RuntimeGroupLeafObj)runtimeHierarchyObj).TraverseAllLeafNodes(ProcessingStages.CreateGroupTree, traversalContext);
flag = false;
}
else
{
((RuntimeDetailObj)runtimeHierarchyObj).CreateInstance(traversalContext);
}
}
}
}
void IHierarchyObj.Traverse(ProcessingStages operation, ITraversalContext traversalContext)
{
if (m_sortHierarchyStruct != null)
{
bool ascending = true;
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = m_sortHierarchyStruct.SortInfo.Value();
if (runtimeSortFilterEventInfo.EventSource.UserSort.SortExpressionScope == null)
{
ascending = runtimeSortFilterEventInfo.SortDirection;
}
m_sortHierarchyStruct.SortTree.Traverse(operation, ascending, traversalContext);
}
if (m_dataHolder != null)
{
using (m_dataHolder.PinValue())
{
m_dataHolder.Value().Traverse(operation, traversalContext);
}
}
if (m_dataRowHolder != null)
{
using (m_hierarchyRoot.PinValue())
{
m_dataRowHolder.Traverse(operation, traversalContext, m_hierarchyRoot.Value());
}
}
}
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 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);
}
public RuntimeCell GetOrCreateCell(AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, IReference <RuntimeDataTablixGroupLeafObj> ownerRef, IReference <RuntimeDataTablixGroupRootObj> currOuterGroupRootRef, out IDisposable cleanupRef)
{
RuntimeDataTablixGroupRootObj runtimeDataTablixGroupRootObj = currOuterGroupRootRef.Value();
int groupLeafIndex = dataRegionDef.OuterGroupingIndexes[runtimeDataTablixGroupRootObj.HierarchyDef.HierarchyDynamicIndex];
return(this.GetOrCreateCellByIndex(groupLeafIndex, dataRegionDef, ownerRef, runtimeDataTablixGroupRootObj, out cleanupRef));
}
internal virtual void CalculateRunningValues(AggregateUpdateContext aggContext)
{
if (m_grouping != null)
{
m_grouping.Traverse(ProcessingStages.RunningValues, m_expression == null || m_expression.Direction, aggContext);
}
if (m_hierarchyObjs == null)
{
return;
}
bool flag = true;
for (int i = 0; i < m_hierarchyObjs.Count; i++)
{
IReference <RuntimeHierarchyObj> reference = m_hierarchyObjs[i];
using (reference.PinValue())
{
RuntimeHierarchyObj runtimeHierarchyObj = reference.Value();
if (!flag || runtimeHierarchyObj is RuntimeGroupLeafObj)
{
((RuntimeGroupLeafObj)runtimeHierarchyObj).TraverseAllLeafNodes(ProcessingStages.RunningValues, aggContext);
flag = false;
}
}
}
}
internal RuntimeCell GetAndPinCell(int key, out IDisposable cleanupRef)
{
cleanupRef = null;
IStorable item;
bool flag;
if (key < m_collection.Count)
{
cleanupRef = m_collection.GetAndPin(key, out item);
flag = (item != null);
}
else
{
item = null;
flag = false;
}
if (flag)
{
if (IsCellReference(item))
{
if (cleanupRef != null)
{
cleanupRef.Dispose();
}
IReference<RuntimeCell> reference = (IReference<RuntimeCell>)item;
reference.PinValue();
cleanupRef = (IDisposable)reference;
return reference.Value();
}
return (RuntimeCell)item;
}
return null;
}
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 bool Remove(T item)
{
this.CheckReadOnly("Remove");
EqualityComparer <T> @default = EqualityComparer <T> .Default;
if (this.m_array != null)
{
using (this.m_array.PinValue())
{
object[] array = this.m_array.Value().Array;
return(this.Remove(item, 0, array, this.m_count, @default));
}
}
bool flag = false;
int count = this.m_buckets.Count;
for (int i = 0; i < count; i++)
{
if (flag)
{
break;
}
IReference <StorableArray> reference = this.m_buckets[i];
using (reference.PinValue())
{
int limit = (i != count - 1) ? this.m_bucketSize : (this.m_count - i * this.m_bucketSize);
object[] array2 = reference.Value().Array;
flag = this.Remove(item, i * this.m_bucketSize, array2, limit, @default);
}
}
return(flag);
}
protected Hashtable GetScopeNames(RuntimeDataRegionObjReference currentScope, string targetScope, out bool inScope)
{
inScope = false;
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)
{
if (!inScope && scopeName.Equals(targetScope))
{
inScope = true;
}
AspNetCore.ReportingServices.ReportIntermediateFormat.Grouping value = null;
if (scope is RuntimeGroupLeafObj)
{
value = ((RuntimeGroupLeafObj)scope).GroupingDef;
}
hashtable.Add(scopeName, value);
}
else if (scope is RuntimeTablixCell && !inScope)
{
inScope = scope.InScope(targetScope);
}
}
return(hashtable);
}
protected Hashtable GetScopeNames(RuntimeDataRegionObjReference currentScope, string targetScope, out int level)
{
level = -1;
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;
if (-1 == level && scopeName.Equals(targetScope))
{
level = grouping.RecursiveLevel;
}
}
hashtable.Add(scopeName, grouping);
}
else if (scope is RuntimeTablixCell && -1 == level)
{
level = scope.RecursiveLevel(targetScope);
}
}
return(hashtable);
}
private void CopyDomainScopeGroupInstance(RuntimeGroupRootObj destination, ScalableDictionary <object, IReference <RuntimeHierarchyObj> > runtimeHierarchyObjRefs)
{
IReference <RuntimeHierarchyObj> reference = null;
DomainScopeContext.DomainScopeInfo currentDomainScope = m_owner.OdpContext.DomainScopeContext.CurrentDomainScope;
foreach (object key in runtimeHierarchyObjRefs.Keys)
{
currentDomainScope.AddKey(key);
reference = runtimeHierarchyObjRefs[key];
using (reference.PinValue())
{
RuntimeHierarchyObj runtimeHierarchyObj = reference.Value();
if (runtimeHierarchyObj.HierarchyObjs == null)
{
RuntimeGroupingObjHash runtimeGroupingObjHash = (RuntimeGroupingObjHash)runtimeHierarchyObj.Grouping;
CopyDomainScopeGroupInstance(destination, runtimeGroupingObjHash.m_hashtable);
}
else
{
Global.Tracer.Assert(runtimeHierarchyObj.HierarchyObjs.Count == 1, "hierarchyObject.HierarchyObjs.Count == 1");
IReference <RuntimeHierarchyObj> reference2 = runtimeHierarchyObj.HierarchyObjs[0];
using (reference2.PinValue())
{
RuntimeDataTablixGroupLeafObj runtimeDataTablixGroupLeafObj = (RuntimeDataTablixGroupLeafObj)reference2.Value();
currentDomainScope.CurrentRow = runtimeDataTablixGroupLeafObj.FirstRow;
destination.NextRow();
}
}
}
currentDomainScope.RemoveKey();
}
}
internal bool IsSortFilterTarget(bool[] isSortFilterTarget, IReference <IScope> outerScope, IReference <IHierarchyObj> target, ref RuntimeUserSortTargetInfo userSortTargetInfo)
{
bool result = false;
if (m_runtimeSortFilterInfo != null && isSortFilterTarget != null && (outerScope == null || !outerScope.Value().TargetForNonDetailSort))
{
for (int i = 0; i < m_runtimeSortFilterInfo.Count; i++)
{
IReference <RuntimeSortFilterEventInfo> reference = m_runtimeSortFilterInfo[i];
using (reference.PinValue())
{
RuntimeSortFilterEventInfo runtimeSortFilterEventInfo = reference.Value();
if (isSortFilterTarget[i] && (outerScope == null || outerScope.Value().TargetScopeMatched(i, detailSort: false)))
{
runtimeSortFilterEventInfo.EventTarget = target;
runtimeSortFilterEventInfo.Processed = false;
if (userSortTargetInfo == null)
{
userSortTargetInfo = new RuntimeUserSortTargetInfo(target, i, reference);
}
else
{
userSortTargetInfo.AddSortInfo(target, i, reference);
}
result = true;
}
}
}
}
return(result);
}
protected static RuntimeDataTablixGroupRootObjReference GetGroupRoot(AspNetCore.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode rifMember, IReference <RuntimeMemberObj>[] memberCol)
{
Global.Tracer.Assert(!rifMember.IsStatic, "Cannot GetGroupRoot of a static member");
IReference <RuntimeMemberObj> reference = memberCol[rifMember.IndexInCollection];
RuntimeMemberObj runtimeMemberObj = reference.Value();
return(runtimeMemberObj.GroupRoot);
}
public override void GetScopeValues(IReference <IHierarchyObj> targetScopeObj, List <object>[] scopeValues, ref int index)
{
if (targetScopeObj != null && this == targetScopeObj.Value())
{
return;
}
this.m_outerScope.Value().GetScopeValues(targetScopeObj, scopeValues, ref index);
}
public void RegisterActiveParent(IReference <IOnDemandScopeInstance> parentScopeInstanceRef)
{
using (parentScopeInstanceRef.PinValue())
{
parentScopeInstanceRef.Value().SetupEnvironment();
m_lastPrimaryKeyValues = m_activeRelationship.EvaluateJoinConditionKeys(evaluatePrimaryKeys: true, m_odpContext.ReportRuntime);
UpdateActiveParent(parentScopeInstanceRef);
}
}
void IScope.GetScopeValues(IReference <IHierarchyObj> targetScopeObj, List <object>[] scopeValues, ref int index)
{
IReference <IScope> currentContainingScope = m_odpContext.UserSortFilterContext.CurrentContainingScope;
if (currentContainingScope != null && (targetScopeObj == null || this != targetScopeObj.Value()))
{
currentContainingScope.Value().GetScopeValues(null, scopeValues, ref index);
}
}
public static bool InitializeSubReports(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, OnDemandProcessingContext odpContext, bool inDataRegion, bool fromCreateSubReportInstance)
{
try
{
odpContext.IsTopLevelSubReportProcessing = true;
bool flag = true;
OnDemandProcessingContext onDemandProcessingContext = odpContext;
foreach (AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport subReport in report.SubReports)
{
if (subReport.ExceededMaxLevel)
{
return(flag);
}
IReference <AspNetCore.ReportingServices.ReportIntermediateFormat.SubReportInstance> reference = null;
try
{
bool flag2 = false;
if (subReport.RetrievalStatus != AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport.Status.DefinitionRetrieveFailed)
{
onDemandProcessingContext = SubReportInitializer.InitializeSubReport(odpContext, subReport, reportInstance, inDataRegion || subReport.InDataRegion, fromCreateSubReportInstance, out flag2);
if (!inDataRegion && !subReport.InDataRegion && (!odpContext.SnapshotProcessing || odpContext.ReprocessSnapshot))
{
reference = subReport.CurrentSubReportInstance;
}
}
if (flag2 && subReport.Report.HasSubReports)
{
flag &= SubReportInitializer.InitializeSubReports(subReport.Report, (subReport.CurrentSubReportInstance != null) ? subReport.CurrentSubReportInstance.Value().ReportInstance.Value() : null, onDemandProcessingContext, inDataRegion || subReport.InDataRegion, fromCreateSubReportInstance);
}
if (onDemandProcessingContext.ErrorContext.Messages != null && 0 < onDemandProcessingContext.ErrorContext.Messages.Count)
{
OnDemandProcessingContext topLevelContext = odpContext.TopLevelContext;
topLevelContext.ErrorContext.Register(ProcessingErrorCode.rsWarningExecutingSubreport, Severity.Warning, subReport.ObjectType, subReport.Name, null, onDemandProcessingContext.ErrorContext.Messages);
}
flag &= flag2;
}
catch (Exception e)
{
flag = false;
AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.HandleSubReportProcessingError(onDemandProcessingContext.TopLevelContext.ErrorContext, subReport, InstancePathItem.GenerateInstancePathString(subReport.InstancePath), onDemandProcessingContext.ErrorContext, e);
}
finally
{
if (reference != null)
{
reference.Value().InstanceComplete();
}
}
}
return(flag);
}
finally
{
odpContext.IsTopLevelSubReportProcessing = false;
}
}
protected void DetailGetScopeValues(IReference <IScope> outerScope, IReference <IHierarchyObj> targetScopeObj, List <object>[] scopeValues, ref int index)
{
Global.Tracer.Assert(null == targetScopeObj, "(null == targetScopeObj)");
outerScope.Value().GetScopeValues(targetScopeObj, scopeValues, ref index);
Global.Tracer.Assert(index < scopeValues.Length, "(index < scopeValues.Length)");
List <object> list = new List <object>(1);
list.Add(this.m_odpContext.ReportObjectModel.FieldsImpl.GetRowIndex());
scopeValues[index++] = list;
}
