protected void HandleDataAction(bool handleMyDataAction, DataActions innerDataAction, DataActions userSortDataAction)
{
if (!handleMyDataAction)
{
m_dataAction = innerDataAction;
}
m_dataAction |= userSortDataAction;
if (m_dataAction != 0)
{
m_dataRows = new ScalableList <DataFieldRow>(m_depth + 1, m_odpContext.TablixProcessingScalabilityCache, 30);
}
}
public override void Deserialize(IntermediateFormatReader reader)
{
base.Deserialize(reader);
reader.RegisterDeclaration(RuntimeDetailObj.m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.OuterScope:
this.m_outerScope = (IReference <IScope>)reader.ReadRIFObject();
break;
case MemberName.DataRegionDef:
{
int id = reader.ReadInt32();
this.m_dataRegionDef = (AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.DataRows:
this.m_dataRows = reader.ReadRIFObject <ScalableList <DataFieldRow> >();
break;
case MemberName.RunningValueValues:
this.m_rvValueList = reader.ReadListOfRIFObjectArrays <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult>();
break;
case MemberName.RunningValuesInGroup:
this.m_runningValuesInGroup = reader.ReadListOfPrimitives <string>();
break;
case MemberName.PreviousValuesInGroup:
this.m_previousValuesInGroup = reader.ReadListOfPrimitives <string>();
break;
case MemberName.GroupCollection:
this.m_groupCollection = reader.ReadStringRIFObjectDictionary <IReference <RuntimeGroupRootObj> >();
break;
case MemberName.OuterDataAction:
this.m_outerDataAction = (DataActions)reader.ReadEnum();
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
protected override void ConstructCellContents(Cell cell, ref DataActions dataAction)
{
List <Microsoft.ReportingServices.ReportIntermediateFormat.ReportItem> cellContents = GetCellContents(cell);
if (cellContents != null)
{
m_owner.Value().OdpContext.TablixProcessingScalabilityCache.AllocateAndPin((RuntimeCell)this, m_outerGroupDynamicIndex);
if (m_cellContents == null)
{
m_cellContents = new RuntimeRICollection(cellContents.Count);
}
m_cellContents.AddItems(m_selfReference, cellContents, ref dataAction, m_owner.Value().OdpContext);
}
}
protected override void ConstructOutermostCellContents(Cell cell)
{
List <Microsoft.ReportingServices.ReportIntermediateFormat.ReportItem> cellContents = GetCellContents(cell);
if (cellContents != null)
{
DataActions dataAction = DataActions.None;
if (m_groupScopedItems == null)
{
m_groupScopedItems = new RuntimeRICollection(cellContents.Count);
}
m_groupScopedItems.AddItems(m_selfReference, cellContents, ref dataAction, m_odpContext);
}
}
public async Task <DeleteResourceResponse> Handle(DeleteResourceRequest message, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(message, nameof(message));
DataActions requiredDataAction = message.HardDelete ? DataActions.Delete | DataActions.HardDelete : DataActions.Delete;
if (await AuthorizationService.CheckAccess(requiredDataAction) != requiredDataAction)
{
throw new UnauthorizedFhirActionException();
}
var key = message.ResourceKey;
if (!string.IsNullOrEmpty(key.VersionId))
{
throw new MethodNotAllowedException(Core.Resources.DeleteVersionNotAllowed);
}
string version = null;
if (message.HardDelete)
{
await FhirDataStore.HardDeleteAsync(key, cancellationToken);
}
else
{
var emptyInstance = (Resource)Activator.CreateInstance(ModelInfo.GetTypeForFhirType(message.ResourceKey.ResourceType));
emptyInstance.Id = message.ResourceKey.Id;
ResourceWrapper deletedWrapper = CreateResourceWrapper(emptyInstance, deleted: true, keepMeta: false);
bool keepHistory = await ConformanceProvider.Value.CanKeepHistory(key.ResourceType, cancellationToken);
UpsertOutcome result = await FhirDataStore.UpsertAsync(
deletedWrapper,
weakETag : null,
allowCreate : true,
keepHistory : keepHistory,
cancellationToken : cancellationToken);
version = result?.Wrapper.Version;
}
if (string.IsNullOrWhiteSpace(version))
{
return(new DeleteResourceResponse(new ResourceKey(key.ResourceType, key.Id)));
}
return(new DeleteResourceResponse(new ResourceKey(key.ResourceType, key.Id, version), WeakETag.FromVersionId(version)));
}
protected override void ConstructOutermostCellContents(Cell cell)
{
List <AspNetCore.ReportingServices.ReportIntermediateFormat.ReportItem> cellContents = this.GetCellContents(cell);
if (cellContents != null)
{
DataActions dataActions = DataActions.None;
if (this.m_groupScopedItems == null)
{
this.m_groupScopedItems = new RuntimeRICollection(cellContents.Count);
}
this.m_groupScopedItems.AddItems(base.m_selfReference, cellContents, ref dataActions, base.m_odpContext);
}
}
public void ShapeInWhereTest3()
{
//new ArcEngineLicense();
RuntimeManager.BindLicense(ProductCode.EngineOrDesktop);
//ESRI.ArcGIS.RuntimeManager.Bind(ESRI.ArcGIS.ProductCode.EngineOrDesktop);
var sdeWs = DataActions.GetSdeWorkspace(new Dictionary <string, object>()
{
{ "INSTANCE", "sde:oracle11g:192.168.0.2/orcl" },
{ "USER", "dzgisdata" },
{ "PASSWORD", "dzgisdata" },
});
var outFcname = $@"C:/test/i{DateTime.Now.ToBinary()}.shp";
var feaWs = (IFeatureWorkspace)sdeWs;
var xzqh = feaWs.OpenFeatureClass("DZGISDATA.XZQH");
//var ydhx = feaWs.OpenFeatureClass("DZGISDATA.YDHX_SP");
IVariantArray arr = new VarArrayClass();
//arr.Add(@"C:\test\dzgisdata02.sde\DZGISDATA.XZQH\DZGISDATA.XZQH");
arr.Add(outFcname);
//IGeoProcessor gp2 = new GeoProcessorClass();
//IGeoProcessorResult result = gp2.Execute("Select", arr, null);
var gp = new Geoprocessor();
var result = gp.Execute(new Select()
{
in_features = @"C:\test\continents.shp",
out_feature_class = outFcname,
}, null);
;
//Select sel = new Select()
//{
// in_features = xzqh,
// out_feature_class = outFcname
//};
//var result = new Geoprocessor().Execute(sel, null);
//var gpResult = (IGeoProcessorResult)result;
//var gpms = gpResult.GetResultMessages();
}
public RuntimeDataTablixObj(IReference <IScope> outerScope, AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataTablixDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, AspNetCore.ReportingServices.ReportProcessing.ObjectType objectType)
: base(outerScope, dataTablixDef, ref dataAction, odpContext, onePassProcess, dataTablixDef.RunningValues, objectType, outerScope.Value().Depth + 1)
{
bool handleMyDataAction = default(bool);
DataActions innerDataAction = default(DataActions);
this.ConstructorHelper(ref dataAction, onePassProcess, out handleMyDataAction, out innerDataAction);
base.m_innerDataAction = innerDataAction;
DataActions userSortDataAction = base.HandleSortFilterEvent();
this.ConstructRuntimeStructure(ref innerDataAction, onePassProcess);
this.HandleDataAction(handleMyDataAction, innerDataAction, userSortDataAction);
base.m_odpContext.CreatedScopeInstance(base.m_dataRegionDef);
this.m_scopeInstanceNumber = RuntimeDataRegionObj.AssignScopeInstanceNumber(base.m_dataRegionDef.DataScopeInfo);
}
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;
}
}
public async Task <DeleteResourceResponse> Handle(ConditionalDeleteResourceRequest request, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(request, nameof(request));
DataActions dataActions = (request.DeleteOperation == DeleteOperation.SoftDelete ? DataActions.Delete : DataActions.HardDelete | DataActions.Delete) | DataActions.Read;
if (await AuthorizationService.CheckAccess(dataActions, cancellationToken) != dataActions)
{
throw new UnauthorizedFhirActionException();
}
if (request.MaxDeleteCount > 1)
{
return(await DeleteMultiple(request, cancellationToken));
}
return(await DeleteSingle(request, cancellationToken));
}
void IHierarchyObj.ProcessUserSort()
{
m_odpContext.ProcessUserSortForTarget((RuntimeRDLDataRegionObjReference)base.SelfReference, ref m_dataRows, m_userSortTargetInfo.TargetForNonDetailSort);
m_dataAction &= ~DataActions.UserSort;
if (m_userSortTargetInfo.TargetForNonDetailSort)
{
m_userSortTargetInfo.ResetTargetForNonDetailSort();
m_userSortTargetInfo.EnterProcessUserSortPhase(m_odpContext);
DataActions innerDataAction = m_innerDataAction;
ConstructRuntimeStructure(ref innerDataAction, m_odpContext.ReportDefinition.MergeOnePass);
if (m_dataAction != 0)
{
m_dataRows = new ScalableList<DataFieldRow>(m_depth, m_odpContext.TablixProcessingScalabilityCache);
}
ScopeFinishSorting(ref m_firstRow, m_userSortTargetInfo);
m_userSortTargetInfo.LeaveProcessUserSortPhase(m_odpContext);
}
}
public void ShapeInWhereTest2()
{
new ArcEngineLicense();
var sdeWs = DataActions.GetSdeWorkspace(new Dictionary <string, object>()
{
{ "INSTANCE", "sde:oracle11g:192.168.0.2/orcl" },
{ "USER", "dzgisdata" },
{ "PASSWORD", "dzgisdata" },
});
var feaWs = (IFeatureWorkspace)sdeWs;
var xzqh = feaWs.OpenFeatureClass("DZGISDATA.XZQH");
var ydhx = feaWs.OpenFeatureClass("DZGISDATA.YDHX_SP");
IGpValueTableObject gpvt = new GpValueTableObjectClass();
gpvt.AddRow(xzqh);
gpvt.AddRow(ydhx);
var outFcname = $@"C:/test/i{DateTime.Now.ToBinary()}.shp";
Intersect intersect = new Intersect()
{
//in_features = @"C:\test\dzgisdata02.sde\DZGISDATA.XZQH\DZGISDATA.XZQH;C:\test\dzgisdata02.sde\DZGISDATA.YWHX\DZGISDATA.YDHX_SP",
in_features = gpvt,
out_feature_class = outFcname,
join_attributes = "ONLY_FID",
output_type = "INPUT"
};
//gpfeatureclass
var result = new Geoprocessor().Execute(intersect, null);
var gpResult = (IGeoProcessorResult)result;
var gpms = gpResult.GetResultMessages();
;
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (DataActions.UserSort == dataAction)
{
RuntimeDataRegionObj.CommonFirstRow(base.m_odpContext, ref base.m_firstRowIsAggregate, ref base.m_firstRow);
base.CommonNextRow(base.m_dataRows);
}
else if (DataActions.AggregatesOfAggregates == dataAction)
{
AggregateUpdateContext aggregateUpdateContext = (AggregateUpdateContext)context;
aggregateUpdateContext.UpdateAggregatesForRow();
}
else
{
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregatesOfAggregates))
{
AggregateUpdateContext aggregateUpdateContext2 = (AggregateUpdateContext)context;
aggregateUpdateContext2.UpdateAggregatesForRow();
}
if (!base.m_dataRegionDef.ProcessCellRunningValues)
{
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregates))
{
if (base.m_postSortAggregates != null)
{
RuntimeDataRegionObj.UpdateAggregates(base.m_odpContext, base.m_postSortAggregates, false);
}
if (base.m_runningValues != null)
{
RuntimeDataTablixObj.UpdateRunningValues(base.m_odpContext, base.m_runningValues);
}
}
if (base.m_outerScope != null && (dataAction & base.m_outerDataAction) != 0)
{
using (base.m_outerScope.PinValue())
{
IScope scope = base.m_outerScope.Value();
scope.ReadRow(dataAction, context);
}
}
}
}
}
internal RuntimeRDLDataRegionObj(IReference<IScope> outerScope, Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, List<Microsoft.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, Microsoft.ReportingServices.ReportProcessing.ObjectType objectType, int level)
: base(odpContext, objectType, level)
{
m_dataRegionDef = dataRegionDef;
m_outerScope = outerScope;
RuntimeDataRegionObj.CreateAggregates(m_odpContext, dataRegionDef.Aggregates, ref m_nonCustomAggregates, ref m_customAggregates);
if (dataRegionDef.DataScopeInfo != null)
{
RuntimeDataRegionObj.CreateAggregates(m_odpContext, dataRegionDef.DataScopeInfo.AggregatesOfAggregates, ref m_aggregatesOfAggregates);
}
if (dataRegionDef.Filters != null)
{
m_filters = new Filters(Filters.FilterTypes.DataRegionFilter, (IReference<Microsoft.ReportingServices.ReportProcessing.ReportProcessing.IFilterOwner>)base.SelfReference, dataRegionDef.Filters, dataRegionDef.ObjectType, dataRegionDef.Name, m_odpContext, level + 1);
return;
}
m_outerDataAction = dataAction;
m_dataAction = dataAction;
dataAction = DataActions.None;
}
protected override void ConstructRuntimeStructure(ref DataActions innerDataAction, bool onePassProcess)
{
CreateRuntimeMemberObjects(m_dataRegionDef.OuterMembers, m_dataRegionDef.InnerMembers, out HierarchyNodeList outerTopLevelStaticMembers, out HierarchyNodeList innerTopLevelStaticMembers, ref innerDataAction);
if (((outerTopLevelStaticMembers != null && outerTopLevelStaticMembers.Count != 0) || (innerTopLevelStaticMembers != null && innerTopLevelStaticMembers.Count != 0)) && base.DataRegionDef.OutermostStaticColumnIndexes == null && base.DataRegionDef.OutermostStaticRowIndexes == null)
{
List <int> list = innerTopLevelStaticMembers?.LeafCellIndexes;
List <int> list2 = outerTopLevelStaticMembers?.LeafCellIndexes;
if (base.DataRegionDef.ProcessingInnerGrouping == Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion.ProcessingInnerGroupings.Column)
{
base.DataRegionDef.OutermostStaticColumnIndexes = list;
base.DataRegionDef.OutermostStaticRowIndexes = list2;
}
else
{
base.DataRegionDef.OutermostStaticColumnIndexes = list2;
base.DataRegionDef.OutermostStaticRowIndexes = list;
}
}
}
public ValueTask <DataActions> CheckAccess(DataActions dataActions)
{
ClaimsPrincipal principal = _requestContextAccessor.FhirRequestContext.Principal;
DataActions permittedDataActions = 0;
foreach (Claim claim in principal.FindAll(_rolesClaimName))
{
if (_roles.TryGetValue(claim.Value, out Role role))
{
permittedDataActions |= role.AllowedDataActions;
if (permittedDataActions == dataActions)
{
break;
}
}
}
return(new ValueTask <DataActions>(dataActions & permittedDataActions));
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (!FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregates) || !FlagUtils.HasFlag(m_dataAction, DataActions.PostSortAggregates))
{
return;
}
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
if (m_hierarchyDef.DataRegionDef.ProcessCellRunningValues)
{
if (m_cellRVs != null)
{
for (int i = 0; i < m_cellRVs.Count; i++)
{
string text = m_cellRVs[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected running value: {0}", text);
aggregateObj.Update();
}
}
if (m_outerScope != null && m_hierarchyDef.DataRegionDef.CellPostSortAggregates != null)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().ReadRow(dataAction, context);
}
}
return;
}
if (m_staticCellRVs != null)
{
for (int j = 0; j < m_staticCellRVs.Count; j++)
{
string text2 = m_staticCellRVs[j];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj2 = aggregatesImpl.GetAggregateObj(text2);
Global.Tracer.Assert(aggregateObj2 != null, "Missing expected running value: {0}", text2);
aggregateObj2.Update();
}
}
base.ReadRow(dataAction, context);
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (DataActions.PostSortAggregates == dataAction && m_runningValuesInGroup != null)
{
AggregatesImpl aggregatesImpl = m_odpContext.ReportObjectModel.AggregatesImpl;
for (int i = 0; i < m_runningValuesInGroup.Count; i++)
{
string text = m_runningValuesInGroup[i];
Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj aggregateObj = aggregatesImpl.GetAggregateObj(text);
Global.Tracer.Assert(aggregateObj != null, "Missing expected running value aggregate: {0}", text);
aggregateObj.Update();
}
}
if (m_outerScope != null && (dataAction & m_outerDataAction) != 0)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().ReadRow(dataAction, context);
}
}
}
public RuntimeRDLDataRegionObj(IReference <IScope> outerScope, AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, List <AspNetCore.ReportingServices.ReportIntermediateFormat.RunningValueInfo> runningValues, AspNetCore.ReportingServices.ReportProcessing.ObjectType objectType, int level)
: base(odpContext, objectType, level)
{
this.m_dataRegionDef = dataRegionDef;
this.m_outerScope = outerScope;
RuntimeDataRegionObj.CreateAggregates(base.m_odpContext, dataRegionDef.Aggregates, ref this.m_nonCustomAggregates, ref this.m_customAggregates);
if (dataRegionDef.DataScopeInfo != null)
{
RuntimeDataRegionObj.CreateAggregates <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>(base.m_odpContext, (BucketedAggregatesCollection <AspNetCore.ReportingServices.ReportIntermediateFormat.DataAggregateInfo>)dataRegionDef.DataScopeInfo.AggregatesOfAggregates, ref this.m_aggregatesOfAggregates);
}
if (dataRegionDef.Filters != null)
{
this.m_filters = new Filters(Filters.FilterTypes.DataRegionFilter, (IReference <AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.IFilterOwner>)base.SelfReference, dataRegionDef.Filters, dataRegionDef.ObjectType, dataRegionDef.Name, base.m_odpContext, level + 1);
}
else
{
this.m_outerDataAction = dataAction;
this.m_dataAction = dataAction;
dataAction = DataActions.None;
}
}
public override void ReadRow(DataActions dataAction, ITraversalContext context)
{
if (DataActions.UserSort == dataAction)
{
RuntimeDataRegionObj.CommonFirstRow(m_odpContext, ref m_firstRowIsAggregate, ref m_firstRow);
CommonNextRow(m_dataRows);
return;
}
if (DataActions.AggregatesOfAggregates == dataAction)
{
((AggregateUpdateContext)context).UpdateAggregatesForRow();
return;
}
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregatesOfAggregates))
{
((AggregateUpdateContext)context).UpdateAggregatesForRow();
}
if (m_dataRegionDef.ProcessCellRunningValues)
{
return;
}
if (FlagUtils.HasFlag(dataAction, DataActions.PostSortAggregates))
{
if (m_postSortAggregates != null)
{
RuntimeDataRegionObj.UpdateAggregates(m_odpContext, m_postSortAggregates, updateAndSetup: false);
}
if (m_runningValues != null)
{
UpdateRunningValues(m_odpContext, m_runningValues);
}
}
if (m_outerScope != null && (dataAction & m_outerDataAction) != 0)
{
using (m_outerScope.PinValue())
{
m_outerScope.Value().ReadRow(dataAction, context);
}
}
}
protected override void ConstructRuntimeStructure(ref DataActions innerDataAction, bool onePassProcess)
{
HierarchyNodeList hierarchyNodeList = default(HierarchyNodeList);
HierarchyNodeList hierarchyNodeList2 = default(HierarchyNodeList);
this.CreateRuntimeMemberObjects(base.m_dataRegionDef.OuterMembers, base.m_dataRegionDef.InnerMembers, out hierarchyNodeList, out hierarchyNodeList2, ref innerDataAction);
if (((hierarchyNodeList != null && hierarchyNodeList.Count != 0) || (hierarchyNodeList2 != null && hierarchyNodeList2.Count != 0)) && base.DataRegionDef.OutermostStaticColumnIndexes == null && base.DataRegionDef.OutermostStaticRowIndexes == null)
{
List <int> list = (hierarchyNodeList2 != null) ? hierarchyNodeList2.LeafCellIndexes : null;
List <int> list2 = (hierarchyNodeList != null) ? hierarchyNodeList.LeafCellIndexes : null;
if (base.DataRegionDef.ProcessingInnerGrouping == AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion.ProcessingInnerGroupings.Column)
{
base.DataRegionDef.OutermostStaticColumnIndexes = list;
base.DataRegionDef.OutermostStaticRowIndexes = list2;
}
else
{
base.DataRegionDef.OutermostStaticColumnIndexes = list2;
base.DataRegionDef.OutermostStaticRowIndexes = list;
}
}
}
public override void Deserialize(IntermediateFormatReader reader)
{
base.Deserialize(reader);
reader.RegisterDeclaration(m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.DataRegionDef:
{
int id2 = reader.ReadInt32();
m_dataRegionDef = (Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion)scalabilityCache.FetchStaticReference(id2);
break;
}
case MemberName.OuterScope:
m_outerScope = (IReference<IScope>)reader.ReadRIFObject();
break;
case MemberName.FirstRow:
m_firstRow = (DataFieldRow)reader.ReadRIFObject();
break;
case MemberName.FirstRowIsAggregate:
m_firstRowIsAggregate = reader.ReadBoolean();
break;
case MemberName.Filters:
{
int id = reader.ReadInt32();
m_filters = (Filters)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.NonCustomAggregates:
m_nonCustomAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
break;
case MemberName.CustomAggregates:
m_customAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
break;
case MemberName.DataAction:
m_dataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.OuterDataAction:
m_outerDataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.RunningValues:
m_runningValues = reader.ReadListOfPrimitives<string>();
break;
case MemberName.PreviousValues:
m_previousValues = reader.ReadListOfPrimitives<string>();
break;
case MemberName.RunningValueValues:
m_runningValueValues = reader.ReadArrayOfRIFObjects<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult>();
break;
case MemberName.RunningValueOfAggregateValues:
m_runningValueOfAggregateValues = reader.ReadArrayOfRIFObjects<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult>();
break;
case MemberName.PostSortAggregates:
m_postSortAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
break;
case MemberName.DataRows:
m_dataRows = reader.ReadRIFObject<ScalableList<DataFieldRow>>();
break;
case MemberName.InnerDataAction:
m_innerDataAction = (DataActions)reader.ReadEnum();
break;
case MemberName.UserSortTargetInfo:
m_userSortTargetInfo = (RuntimeUserSortTargetInfo)reader.ReadRIFObject();
break;
case MemberName.SortFilterExpressionScopeInfoIndices:
m_sortFilterExpressionScopeInfoIndices = reader.ReadInt32Array();
break;
case MemberName.InDataRowSortPhase:
m_inDataRowSortPhase = reader.ReadBoolean();
break;
case MemberName.SortedDataRowTree:
m_sortedDataRowTree = (BTree)reader.ReadRIFObject();
break;
case MemberName.DataRowSortExpression:
m_dataRowSortExpression = (RuntimeExpressionInfo)reader.ReadRIFObject();
break;
case MemberName.AggregatesOfAggregates:
m_aggregatesOfAggregates = (BucketedDataAggregateObjs)reader.ReadRIFObject();
break;
case MemberName.PostSortAggregatesOfAggregates:
m_postSortAggregatesOfAggregates = (BucketedDataAggregateObjs)reader.ReadRIFObject();
break;
case MemberName.HasProcessedAggregateRow:
m_hasProcessedAggregateRow = reader.ReadBoolean();
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
protected RuntimeDetailObj(IReference <IScope> outerScope, AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataRegionDef, DataActions dataAction, OnDemandProcessingContext odpContext, AspNetCore.ReportingServices.ReportProcessing.ObjectType objectType)
: base(odpContext, objectType, (outerScope == null) ? dataRegionDef.InnerGroupingDynamicMemberCount : (outerScope.Value().Depth + 1))
{
base.m_hierarchyRoot = (RuntimeDetailObjReference)base.SelfReference;
this.m_outerScope = outerScope;
this.m_dataRegionDef = dataRegionDef;
this.m_outerDataAction = dataAction;
}
public abstract void ReadRow(DataActions dataAction, ITraversalContext context);
public RuntimeCriObj(IReference <IScope> outerScope, AspNetCore.ReportingServices.ReportIntermediateFormat.CustomReportItem criDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess)
: base(outerScope, (AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion)criDef, ref dataAction, odpContext, onePassProcess, AspNetCore.ReportingServices.ReportProcessing.ObjectType.CustomReportItem)
{
}
internal RuntimeDataTablixObj(IReference <IScope> outerScope, Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion dataTablixDef, ref DataActions dataAction, OnDemandProcessingContext odpContext, bool onePassProcess, Microsoft.ReportingServices.ReportProcessing.ObjectType objectType)
: base(outerScope, dataTablixDef, ref dataAction, odpContext, onePassProcess, dataTablixDef.RunningValues, objectType, outerScope.Value().Depth + 1)
{
ConstructorHelper(ref dataAction, onePassProcess, out bool handleMyDataAction, out DataActions innerDataAction);
m_innerDataAction = innerDataAction;
DataActions userSortDataAction = HandleSortFilterEvent();
ConstructRuntimeStructure(ref innerDataAction, onePassProcess);
HandleDataAction(handleMyDataAction, innerDataAction, userSortDataAction);
m_odpContext.CreatedScopeInstance(m_dataRegionDef);
m_scopeInstanceNumber = RuntimeDataRegionObj.AssignScopeInstanceNumber(m_dataRegionDef.DataScopeInfo);
}
internal override void CalculateRunningValues(Dictionary <string, IReference <RuntimeGroupRootObj> > groupCol, IReference <RuntimeGroupRootObj> lastGroup, AggregateUpdateContext aggContext)
{
if (m_dataRegionDef.RunningValues != null && m_runningValues == null && m_previousValues == null)
{
AddRunningValues(m_odpContext, m_dataRegionDef.RunningValues, ref m_runningValues, ref m_previousValues, groupCol, lastGroup);
}
if (m_dataRegionDef.DataScopeInfo != null)
{
List <string> runningValuesInGroup = null;
List <string> previousValuesInGroup = null;
AddRunningValues(m_odpContext, m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref runningValuesInGroup, ref previousValuesInGroup, groupCol, lastGroup);
}
bool flag = m_dataRows != null && FlagUtils.HasFlag(m_dataAction, DataActions.PostSortAggregates);
AggregateUpdateQueue workQueue = RuntimeDataRegionObj.AggregateOfAggregatesStart(aggContext, this, m_dataRegionDef.DataScopeInfo, m_postSortAggregatesOfAggregates, flag ? AggregateUpdateFlags.ScopedAggregates : AggregateUpdateFlags.Both, needsSetupEnvironment: true);
if (flag)
{
DataActions dataActions = DataActions.PostSortAggregates;
if (aggContext.LastScopeNeedsRowAggregateProcessing())
{
dataActions |= DataActions.PostSortAggregatesOfAggregates;
}
ReadRows(dataActions, aggContext);
m_dataRows = null;
}
int num = (m_outerGroupings != null) ? m_outerGroupings.Length : 0;
if (num == 0)
{
if (m_innerGroupings != null)
{
for (int i = 0; i < m_innerGroupings.Length; i++)
{
IReference <RuntimeMemberObj> reference = m_innerGroupings[i];
using (reference.PinValue())
{
reference.Value().CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
}
}
else
{
for (int j = 0; j < num; j++)
{
IReference <RuntimeMemberObj> reference2 = m_outerGroupings[j];
bool flag2;
using (reference2.PinValue())
{
RuntimeMemberObj runtimeMemberObj = reference2.Value();
runtimeMemberObj.CalculateRunningValues(groupCol, lastGroup, aggContext);
flag2 = (runtimeMemberObj.GroupRoot == null);
}
if (!flag2 || m_innerGroupings == null)
{
continue;
}
for (int k = 0; k < m_innerGroupings.Length; k++)
{
IReference <RuntimeMemberObj> reference3 = m_innerGroupings[k];
using (reference3.PinValue())
{
RuntimeMemberObj runtimeMemberObj2 = reference3.Value();
runtimeMemberObj2.PrepareCalculateRunningValues();
runtimeMemberObj2.CalculateRunningValues(groupCol, lastGroup, aggContext);
}
}
}
}
CalculateRunningValuesForTopLevelStaticContents(groupCol, lastGroup, aggContext);
RuntimeDataRegionObj.AggregatesOfAggregatesEnd(this, aggContext, workQueue, m_dataRegionDef.DataScopeInfo, m_postSortAggregatesOfAggregates, updateAggsIfNeeded: true);
CalculateDRPreviousAggregates();
RuntimeRICollection.StoreRunningValues(m_odpContext.ReportObjectModel.AggregatesImpl, m_dataRegionDef.RunningValues, ref m_runningValueValues);
if (m_dataRegionDef.DataScopeInfo != null)
{
RuntimeRICollection.StoreRunningValues(m_odpContext.ReportObjectModel.AggregatesImpl, m_dataRegionDef.DataScopeInfo.RunningValuesOfAggregates, ref m_runningValueOfAggregateValues);
}
}
private void CreateRuntimeMemberObjects(HierarchyNodeList outerMembers, HierarchyNodeList innerMembers, out HierarchyNodeList outerTopLevelStaticMembers, out HierarchyNodeList innerTopLevelStaticMembers, ref DataActions innerDataAction)
{
bool hasOppositeStaticLeafMembers = false;
HierarchyNodeList topLevelDynamicMembers = null;
outerTopLevelStaticMembers = null;
if (outerMembers != null)
{
hasOppositeStaticLeafMembers = outerMembers.HasStaticLeafMembers;
topLevelDynamicMembers = outerMembers.DynamicMembersAtScope;
outerTopLevelStaticMembers = outerMembers.StaticMembersInSameScope;
}
bool hasOppositeStaticLeafMembers2 = false;
HierarchyNodeList topLevelDynamicMembers2 = null;
innerTopLevelStaticMembers = null;
if (innerMembers != null)
{
hasOppositeStaticLeafMembers2 = innerMembers.HasStaticLeafMembers;
topLevelDynamicMembers2 = innerMembers.DynamicMembersAtScope;
innerTopLevelStaticMembers = innerMembers.StaticMembersInSameScope;
}
DataActions groupingDataAction = DataActions.None;
CreateTopLevelRuntimeGroupings(ref groupingDataAction, ref m_innerGroupings, innerTopLevelStaticMembers, topLevelDynamicMembers2, null, hasOppositeStaticLeafMembers);
Global.Tracer.Assert(m_innerGroupings != null && m_innerGroupings.Length >= 1, "(null != m_innerGroupings && m_innerGroupings.Length >= 1)");
CreateTopLevelRuntimeGroupings(ref innerDataAction, ref m_outerGroupings, outerTopLevelStaticMembers, topLevelDynamicMembers, m_innerGroupings, hasOppositeStaticLeafMembers2);
}
protected abstract void ConstructRuntimeStructure(ref DataActions innerDataAction, bool onePassProcess);
protected void ConstructorHelper(ref DataActions dataAction, bool onePassProcess, out bool handleMyDataAction, out DataActions innerDataAction)
{
innerDataAction = m_dataAction;
handleMyDataAction = false;
if (onePassProcess)
{
if (m_dataRegionDef.RunningValues != null && 0 < m_dataRegionDef.RunningValues.Count)
{
RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.RunningValues, ref m_nonCustomAggregates);
}
RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.PostSortAggregates, ref m_nonCustomAggregates);
RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.CellPostSortAggregates, ref m_nonCustomAggregates);
}
else
{
if (m_dataRegionDef.RunningValues != null && 0 < m_dataRegionDef.RunningValues.Count)
{
m_dataAction |= DataActions.PostSortAggregates;
}
if (m_dataRegionDef.PostSortAggregates != null && m_dataRegionDef.PostSortAggregates.Count != 0)
{
RuntimeDataRegionObj.CreateAggregates(m_odpContext, m_dataRegionDef.PostSortAggregates, ref m_postSortAggregates);
m_dataAction |= DataActions.PostSortAggregates;
handleMyDataAction = true;
}
if (m_dataRegionDef.DataScopeInfo != null)
{
DataScopeInfo dataScopeInfo = m_dataRegionDef.DataScopeInfo;
if (dataScopeInfo.PostSortAggregatesOfAggregates != null && !dataScopeInfo.PostSortAggregatesOfAggregates.IsEmpty)
{
RuntimeDataRegionObj.CreateAggregates(m_odpContext, dataScopeInfo.PostSortAggregatesOfAggregates, ref m_postSortAggregatesOfAggregates);
}
if (dataScopeInfo.HasAggregatesToUpdateAtRowScope)
{
m_dataAction |= DataActions.AggregatesOfAggregates;
handleMyDataAction = true;
}
}
if (handleMyDataAction)
{
innerDataAction = DataActions.None;
}
else
{
innerDataAction = m_dataAction;
}
}
m_inDataRowSortPhase = (m_dataRegionDef.Sorting != null && m_dataRegionDef.Sorting.ShouldApplySorting);
if (m_inDataRowSortPhase)
{
m_sortedDataRowTree = new BTree(this, m_odpContext, m_depth);
m_dataRowSortExpression = new RuntimeExpressionInfo(m_dataRegionDef.Sorting.SortExpressions, m_dataRegionDef.Sorting.ExprHost, m_dataRegionDef.Sorting.SortDirections, 0);
m_odpContext.AddSpecialDataRowSort((IReference <IDataRowSortOwner>)base.SelfReference);
}
m_dataRegionDef.ResetInstanceIndexes();
m_outerGroupingCounters = new int[m_dataRegionDef.OuterGroupingDynamicMemberCount];
for (int i = 0; i < m_outerGroupingCounters.Length; i++)
{
m_outerGroupingCounters[i] = -1;
}
}
private static void DataConnection_AfterDataConnection(object sender, DataActions action)
{
if (action == DataActions.Insert || action == DataActions.Update)
Scheduler.Reschedule();
}