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; }