private static void TraceMetadata(OnDemandMetadata odpMetadata, int level)
{
if (odpMetadata == null)
{
return;
}
if (odpMetadata.ReportSnapshot != null)
{
Global.Tracer.Trace("{0}ReportSnapshot: Time={1}, Language={2}, User={3}, Path={4}", GetEmptyString(level), odpMetadata.ReportSnapshot.ExecutionTime, odpMetadata.ReportSnapshot.Language, odpMetadata.ReportSnapshot.RequestUserName, odpMetadata.ReportSnapshot.ReportServerUrl + odpMetadata.ReportSnapshot.ReportFolder);
Global.Tracer.Trace("{0}Snapshot flags: Bookmarks={1}, DocumentMap={2}, ShowHide={3}, UserSort={4}", GetEmptyString(level), odpMetadata.ReportSnapshot.HasBookmarks, odpMetadata.ReportSnapshot.HasDocumentMap, odpMetadata.ReportSnapshot.HasShowHide, odpMetadata.ReportSnapshot.HasUserSortFilter);
}
if (odpMetadata.DataChunkMap == null)
{
return;
}
Global.Tracer.Trace("{0}Data chunk map: ", GetEmptyString(level));
lock (odpMetadata.DataChunkMap)
{
IDictionaryEnumerator dictionaryEnumerator = odpMetadata.DataChunkMap.GetEnumerator();
while (dictionaryEnumerator.MoveNext())
{
Global.Tracer.Trace("{0}Data chunk={1}", GetEmptyString(level + 1), (string)dictionaryEnumerator.Key);
TraceDataSetInstance(dictionaryEnumerator.Value as DataSetInstance, level + 2);
}
}
}
protected override OnDemandMetadata PrepareMetadata()
{
OnDemandMetadata onDemandMetadata = new OnDemandMetadata(base.ReportDefinition);
AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot2 = onDemandMetadata.ReportSnapshot = new AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot(base.ReportDefinition, base.PublicProcessingContext.ReportContext.ItemName, base.PublicProcessingContext.Parameters, base.PublicProcessingContext.RequestUserName, this.m_executionTime, base.PublicProcessingContext.ReportContext.HostRootUri, base.PublicProcessingContext.ReportContext.ParentPath, base.PublicProcessingContext.UserLanguage.Name);
return(onDemandMetadata);
}
internal static void TraceReportInstance(OnDemandMetadata odpMetadata, ReportInstance reportInstance, Report reportDefinition, int level)
{
if (!Global.Tracer.TraceVerbose || reportInstance == null)
{
return;
}
if (odpMetadata != null)
{
TraceMetadata(odpMetadata, level);
}
Global.Tracer.Trace("{0}Report: NoRows={1}, Language={2}, Variables={3}", GetEmptyString(level), reportInstance.NoRows, reportInstance.Language, FlattenObjectArray(reportInstance.VariableValues));
if (odpMetadata == null && reportDefinition != null && reportDefinition.MappingDataSetIndexToDataSet.Count > 0)
{
Global.Tracer.Trace("{0}{1} DataSetInstances: ", GetEmptyString(level), reportDefinition.MappingDataSetIndexToDataSet.Count);
IEnumerator cachedDataSetInstances = reportInstance.GetCachedDataSetInstances();
while (cachedDataSetInstances.MoveNext())
{
DataSetInstance dataSetInstance = (DataSetInstance)cachedDataSetInstances.Current;
if (dataSetInstance != null)
{
TraceDataSetInstance(dataSetInstance, level + 1);
}
}
}
TraceScopeInstance(reportInstance, level);
}
protected override OnDemandMetadata PrepareMetadata()
{
OnDemandMetadata onDemandMetadata = base.PrepareMetadata();
onDemandMetadata.PrepareForCachedDataProcessing(this.m_odpMetadataFromDataCache);
return(onDemandMetadata);
}
public ProcessReportOdpSnapshot(IConfiguration configuration, ProcessingContext pc, Microsoft.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, OnDemandMetadata odpMetadataFromSnapshot)
: base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext)
{
Global.Tracer.Assert(odpMetadataFromSnapshot != null, "Must provide existing metadata when processing an existing snapshot");
Global.Tracer.Assert(odpMetadataFromSnapshot.OdpChunkManager != null && odpMetadataFromSnapshot.ReportSnapshot != null, "Must provide chunk manager and ReportSnapshot when processing an existing snapshot");
m_odpMetadataFromSnapshot = odpMetadataFromSnapshot;
}
protected override OnDemandProcessingContext CreateOnDemandContext(OnDemandMetadata odpMetadata, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot, UserProfileState initialUserDependency)
{
OnDemandProcessingContext onDemandProcessingContext = new OnDemandProcessingContext(base.PublicProcessingContext, base.ReportDefinition, odpMetadata, base.ErrorContext, reportSnapshot.ExecutionTime, base.StoreServerParameters, initialUserDependency, base.ExecutionLogContext, base.Configuration, this.GetAbortHelper());
onDemandProcessingContext.ReportObjectModel.Initialize(base.PublicProcessingContext.Parameters);
return(onDemandProcessingContext);
}
public string GetFileStreamName(AspNetCore.ReportingServices.OnDemandReportRendering.RenderingContext renderingContext, string url)
{
string text = null;
OnDemandMetadata odpMetadata = renderingContext.OdpContext.OdpMetadata;
ShapefileInfo shapefileInfo = default(ShapefileInfo);
if (odpMetadata.TryGetShapefile(url, out shapefileInfo))
{
if (shapefileInfo.ErrorOccurred)
{
return(null);
}
text = shapefileInfo.StreamName;
}
else
{
byte[] array = default(byte[]);
if (!this.GetFileData(renderingContext, url, out array) || array == null)
{
shapefileInfo = new ShapefileInfo(null);
shapefileInfo.ErrorOccurred = true;
}
else
{
text = this.StoreShapefileInChunk(renderingContext, array);
shapefileInfo = new ShapefileInfo(text);
}
odpMetadata.AddShapefile(url, shapefileInfo);
}
return(text);
}
internal static void EnsureGroupTreeStorageSetup(OnDemandMetadata odpMetadata, IChunkFactory chunkFactory, GlobalIDOwnerCollection globalIDOwnerCollection, bool openExisting, int rifCompatVersion, bool prohibitSerializableValues)
{
if (odpMetadata.GroupTreeScalabilityCache == null)
{
IStorage storage = new RIFAppendOnlyStorage(BuildChunkStreamHandler("GroupTree", Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Main, chunkFactory, openExisting), default(GroupTreeRIFObjectCreator), GroupTreeReferenceCreator.Instance, globalIDOwnerCollection, openExisting, rifCompatVersion, prohibitSerializableValues);
odpMetadata.GroupTreeScalabilityCache = new GroupTreeScalabilityCache(odpMetadata.GroupTreePartitionManager, storage);
}
}
public static void SerializeMetadata(IChunkFactory chunkFactory, OnDemandMetadata odpMetadata, int compatVersion, bool prohibitSerializableValues)
{
odpMetadata.UpdateLastAssignedGlobalID();
using (Stream str = chunkFactory.CreateChunk("Metadata", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Main, null))
{
new IntermediateFormatWriter(str, compatVersion, prohibitSerializableValues).Write(odpMetadata);
}
}
internal static void EnsureLookupStorageSetup(OnDemandMetadata odpMetadata, IChunkFactory chunkFactory, bool openExisting, int rifCompatVersion, bool prohibitSerializableValues)
{
if (odpMetadata.LookupScalabilityCache == null)
{
new AppendOnlySpaceManager();
IStorage storage = new RIFAppendOnlyStorage(BuildChunkStreamHandler("LookupInfo", Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.LookupInfo, chunkFactory, openExisting), default(LookupRIFObjectCreator), LookupReferenceCreator.Instance, null, openExisting, rifCompatVersion, prohibitSerializableValues);
odpMetadata.LookupScalabilityCache = new LookupScalabilityCache(odpMetadata.LookupPartitionManager, storage);
}
}
protected override void ProcessReport(ProcessingErrorContext errorContext, ExecutionLogContext executionLogContext, ref UserProfileState userProfileState)
{
OnDemandMetadata onDemandMetadata = null;
AspNetCore.ReportingServices.ReportIntermediateFormat.Report report = default(AspNetCore.ReportingServices.ReportIntermediateFormat.Report);
GlobalIDOwnerCollection globalIDOwnerCollection = AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager.DeserializeOdpReportSnapshot(base.PublicProcessingContext, (IChunkFactory)null, errorContext, true, true, base.Configuration, ref onDemandMetadata, out report);
base.m_odpReportSnapshot = onDemandMetadata.ReportSnapshot;
ProcessReportOdpSnapshot processReportOdpSnapshot = new ProcessReportOdpSnapshot(base.Configuration, base.PublicProcessingContext, report, errorContext, base.PublicRenderingContext.StoreServerParametersCallback, globalIDOwnerCollection, executionLogContext, onDemandMetadata);
((ProcessReportOdp)processReportOdpSnapshot).Execute(out base.m_odpContext);
}
protected override void ProcessReport(ProcessingErrorContext errorContext, ExecutionLogContext executionLogContext, ref UserProfileState userProfileState)
{
OnDemandMetadata odpMetadata = null;
Microsoft.ReportingServices.ReportIntermediateFormat.Report report;
GlobalIDOwnerCollection globalIDOwnerCollection = Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager.DeserializeOdpReportSnapshot(base.PublicProcessingContext, null, errorContext, fetchSubreports: true, deserializeGroupTree: true, base.Configuration, ref odpMetadata, out report);
m_odpReportSnapshot = odpMetadata.ReportSnapshot;
new ProcessReportOdpSnapshot(base.Configuration, base.PublicProcessingContext, report, errorContext, base.PublicRenderingContext.StoreServerParametersCallback, globalIDOwnerCollection, executionLogContext, odpMetadata).Execute(out m_odpContext);
}
public static Stream OpenExistingDocumentMapStream(OnDemandMetadata odpMetadata, ICatalogItemContext reportContext, IChunkFactory chunkFactory)
{
Stream stream = null;
if (!odpMetadata.ReportSnapshot.CanUseExistingDocumentMapChunk(reportContext))
{
return(null);
}
string text = default(string);
return(chunkFactory.GetChunk("DocumentMap", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Interactivity, ChunkMode.Open, out text));
}
protected override void ProcessReport(ProcessingErrorContext errorContext, ExecutionLogContext executionLogContext, ref UserProfileState userProfileState)
{
OnDemandMetadata onDemandMetadata = null;
GlobalIDOwnerCollection globalIDOwnerCollection = new GlobalIDOwnerCollection();
onDemandMetadata = Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager.DeserializeOnDemandMetadata(m_dataCacheChunks, globalIDOwnerCollection);
globalIDOwnerCollection = new GlobalIDOwnerCollection();
Microsoft.ReportingServices.ReportIntermediateFormat.Report report = ReportProcessing.DeserializeKatmaiReport(base.PublicProcessingContext.ChunkFactory, keepReferences: false, globalIDOwnerCollection);
ProcessReportOdpWithCachedData processReportOdpWithCachedData = new ProcessReportOdpWithCachedData(base.Configuration, base.PublicProcessingContext, report, errorContext, base.PublicRenderingContext.StoreServerParametersCallback, globalIDOwnerCollection, executionLogContext, m_executionTimeStamp, onDemandMetadata);
m_odpReportSnapshot = processReportOdpWithCachedData.Execute(out m_odpContext);
}
internal static Stream OpenExistingDocumentMapStream(OnDemandMetadata odpMetadata, ICatalogItemContext reportContext, IChunkFactory chunkFactory)
{
Stream stream = null;
if (!odpMetadata.ReportSnapshot.CanUseExistingDocumentMapChunk(reportContext))
{
return(null);
}
string mimeType;
return(chunkFactory.GetChunk("DocumentMap", Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Interactivity, ChunkMode.Open, out mimeType));
}
public Stream GetTileData(string url, out string mimeType, AspNetCore.ReportingServices.OnDemandReportRendering.RenderingContext renderingContext)
{
OnDemandMetadata odpMetadata = renderingContext.OdpContext.OdpMetadata;
ImageInfo imageInfo = default(ImageInfo);
if (odpMetadata.TryGetExternalImage(url, out imageInfo))
{
IChunkFactory chunkFactory = renderingContext.OdpContext.ChunkFactory;
return(chunkFactory.GetChunk(imageInfo.StreamName, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Image, ChunkMode.Open, out mimeType));
}
mimeType = null;
return(null);
}
public static void PreparePartitionedTreesForSyncSerialization(OnDemandProcessingContext odpContext)
{
OnDemandMetadata odpMetadata = odpContext.OdpMetadata;
if (odpMetadata.GroupTreeScalabilityCache != null)
{
odpMetadata.GroupTreeScalabilityCache.PrepareForFlush();
}
if (odpMetadata.LookupScalabilityCache != null)
{
odpMetadata.LookupScalabilityCache.PrepareForFlush();
}
}
public LookupTable GetLookupTable(OnDemandProcessingContext odpContext)
{
if (this.m_lookupTable == null)
{
Global.Tracer.Assert(this.HasBeenTransferred, "Invalid LookupObjResult: PartitionID for LookupTable is empty.");
OnDemandMetadata odpMetadata = odpContext.OdpMetadata;
odpMetadata.EnsureLookupScalabilitySetup(odpContext.ChunkFactory, odpContext.GetActiveCompatibilityVersion(), odpContext.ProhibitSerializableValues);
long treePartitionOffset = odpMetadata.LookupPartitionManager.GetTreePartitionOffset(this.m_lookupTablePartitionId);
LookupScalabilityCache lookupScalabilityCache = odpMetadata.LookupScalabilityCache;
this.m_lookupTable = (LookupTable)lookupScalabilityCache.Storage.Retrieve(treePartitionOffset);
this.m_lookupTable.SetEqualityComparer(odpContext.ProcessingComparer);
}
return(this.m_lookupTable);
}
public void GenerateGroupTree()
{
Global.Tracer.Trace(TraceLevel.Verbose, "Data processing complete. Beginning group tree creation");
OnDemandMetadata odpMetadata = this.m_odpContext.OdpMetadata;
AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager.EnsureGroupTreeStorageSetup(odpMetadata, this.m_odpContext.ChunkFactory, odpMetadata.GlobalIDOwnerCollection, false, this.m_odpContext.GetActiveCompatibilityVersion(), this.m_odpContext.ProhibitSerializableValues);
this.CreateInstances();
if (!this.m_odpContext.InSubreportInDataRegion)
{
this.m_odpContext.TopLevelContext.MergeNewUserSortFilterInformation();
odpMetadata.ResetUserSortFilterContexts();
}
this.m_dataSetObj.CompleteLookupProcessing();
}
public void TransferToLookupCache(OnDemandProcessingContext odpContext)
{
Global.Tracer.Assert(this.m_lookupTable != null, "Can't transfer a missing LookupTable");
Global.Tracer.Assert(!this.HasBeenTransferred, "Can't transfer a LookupTable twice");
OnDemandMetadata odpMetadata = odpContext.OdpMetadata;
odpMetadata.EnsureLookupScalabilitySetup(odpContext.ChunkFactory, odpContext.GetActiveCompatibilityVersion(), odpContext.ProhibitSerializableValues);
LookupScalabilityCache lookupScalabilityCache = odpMetadata.LookupScalabilityCache;
IReference <LookupTable> reference = lookupScalabilityCache.AllocateEmptyTreePartition <LookupTable>(AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.LookupTableReference);
this.m_lookupTable.TransferTo(lookupScalabilityCache);
lookupScalabilityCache.SetTreePartitionContentsAndPin(reference, this.m_lookupTable);
this.m_lookupTablePartitionId = reference.Id;
reference.UnPinValue();
}
internal string GetFileStreamName(Microsoft.ReportingServices.OnDemandReportRendering.RenderingContext renderingContext, string url)
{
string text = null;
OnDemandMetadata odpMetadata = renderingContext.OdpContext.OdpMetadata;
if (odpMetadata.TryGetShapefile(url, out ShapefileInfo shapefileInfo))
{
if (shapefileInfo.ErrorOccurred)
{
return(null);
}
text = shapefileInfo.StreamName;
}
else
{
if (!GetFileData(renderingContext, url, out byte[] data) || data == null)
public void SerializeSnapshot()
{
Global.Tracer.Assert(null != this.m_odpContext, "OnDemandProcessingContext is unavailable");
OnDemandMetadata odpMetadata = this.m_odpContext.OdpMetadata;
if (odpMetadata.SnapshotHasChanged)
{
try
{
IReference <ReportInstance> reportInstance = odpMetadata.ReportInstance;
Global.Tracer.Assert(reportInstance != null, "Missing GroupTreeRoot");
if (odpMetadata.IsInitialProcessingRequest)
{
reportInstance.UnPinValue();
}
if (odpMetadata.GroupTreeHasChanged || odpMetadata.IsInitialProcessingRequest)
{
GroupTreeScalabilityCache groupTreeScalabilityCache = this.m_odpContext.OdpMetadata.GroupTreeScalabilityCache;
groupTreeScalabilityCache.Flush();
if (odpMetadata.IsInitialProcessingRequest)
{
GroupTreePartition groupTreePartition = new GroupTreePartition();
groupTreePartition.AddTopLevelScopeInstance((IReference <ScopeInstance>)reportInstance);
long groupTreeRootOffset = groupTreeScalabilityCache.Storage.Allocate(groupTreePartition);
groupTreeScalabilityCache.Storage.Flush();
odpMetadata.GroupTreeRootOffset = groupTreeRootOffset;
}
}
if (odpMetadata.LookupInfoHasChanged)
{
LookupScalabilityCache lookupScalabilityCache = this.m_odpContext.OdpMetadata.LookupScalabilityCache;
lookupScalabilityCache.Flush();
}
OnDemandProcessingManager.SerializeMetadata(this.m_odpContext.ChunkFactory, this.m_odpContext.OdpMetadata, this.m_odpContext.GetActiveCompatibilityVersion(), this.m_odpContext.ProhibitSerializableValues);
OnDemandProcessingManager.SerializeSortFilterEventInfo(this.m_odpContext);
}
finally
{
if (odpMetadata != null)
{
odpMetadata.DisposePersistedTreeScalability();
}
}
}
}
public ReportInstance(OnDemandProcessingContext odpContext, Report reportDef, ParameterInfoCollection parameters)
{
int count = reportDef.MappingNameToDataSet.Count;
this.m_dataSetInstances = new DataSetInstance[count];
List <DataRegion> topLevelDataRegions = reportDef.TopLevelDataRegions;
if (topLevelDataRegions != null)
{
OnDemandMetadata odpMetadata = odpContext.OdpMetadata;
GroupTreeScalabilityCache groupTreeScalabilityCache = odpMetadata.GroupTreeScalabilityCache;
int count2 = topLevelDataRegions.Count;
base.m_dataRegionInstances = new List <IReference <DataRegionInstance> >(count2);
for (int i = 0; i < count2; i++)
{
base.m_dataRegionInstances.Add(groupTreeScalabilityCache.AllocateEmptyTreePartition <DataRegionInstance>(AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.DataRegionInstanceReference));
}
}
}
internal static OnDemandMetadata DeserializeOnDemandMetadata(IChunkFactory chunkFactory, GlobalIDOwnerCollection globalIDOwnerCollection)
{
Stream stream = null;
try
{
stream = chunkFactory.GetChunk("Metadata", Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Main, ChunkMode.Open, out string _);
IntermediateFormatReader intermediateFormatReader = new IntermediateFormatReader(stream, default(GroupTreeRIFObjectCreator), globalIDOwnerCollection);
OnDemandMetadata onDemandMetadata = (OnDemandMetadata)intermediateFormatReader.ReadRIFObject();
Global.Tracer.Assert(onDemandMetadata != null, "(null != odpMetadata)");
stream.Close();
stream = null;
onDemandMetadata.OdpChunkManager = new OnDemandProcessingManager();
return(onDemandMetadata);
}
finally
{
stream?.Close();
}
}
public static OnDemandMetadata DeserializeOnDemandMetadata(IChunkFactory chunkFactory, GlobalIDOwnerCollection globalIDOwnerCollection)
{
Stream stream = null;
try
{
string text = default(string);
stream = chunkFactory.GetChunk("Metadata", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Main, ChunkMode.Open, out text);
IntermediateFormatReader intermediateFormatReader = new IntermediateFormatReader(stream, (IRIFObjectCreator)(object)default(GroupTreeRIFObjectCreator), globalIDOwnerCollection);
OnDemandMetadata onDemandMetadata = (OnDemandMetadata)intermediateFormatReader.ReadRIFObject();
Global.Tracer.Assert(null != onDemandMetadata, "(null != odpMetadata)");
stream.Close();
stream = null;
onDemandMetadata.OdpChunkManager = new OnDemandProcessingManager();
return(onDemandMetadata);
}
finally
{
if (stream != null)
{
stream.Close();
}
}
}
internal static IReference <DataRegionInstance> CreateInstance(ScopeInstance parentInstance, OnDemandMetadata odpMetadata, DataRegion dataRegionDef, int dataSetIndex)
{
DataRegionInstance dataRegionInstance = new DataRegionInstance(dataRegionDef, dataSetIndex);
GroupTreeScalabilityCache groupTreeScalabilityCache = odpMetadata.GroupTreeScalabilityCache;
IReference <DataRegionInstance> reference;
if (parentInstance.ObjectType == Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ReportInstance)
{
reference = ((ReportInstance)parentInstance).GetTopLevelDataRegionReference(dataRegionDef.IndexInCollection);
groupTreeScalabilityCache.SetTreePartitionContentsAndPin(reference, dataRegionInstance);
}
else
{
reference = groupTreeScalabilityCache.AllocateAndPin(dataRegionInstance, 0);
parentInstance.AddChildScope((IReference <ScopeInstance>)reference, dataRegionDef.IndexInCollection);
}
dataRegionInstance.m_cleanupRef = (IDisposable)reference;
return(reference);
}
public ProcessReportOdpSnapshotReprocessing(IConfiguration configuration, ProcessingContext pc, Microsoft.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, OnDemandMetadata odpMetadataFromSnapshot)
: base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext, odpMetadataFromSnapshot)
{
}
internal static string StoreImageDataInChunk(Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes chunkType, byte[] imageData, string mimeType, OnDemandMetadata odpMetadata, IChunkFactory chunkFactory)
{
string text = GenerateImageStreamName();
_ = odpMetadata.ReportSnapshot;
using (Stream stream = chunkFactory.CreateChunk(text, chunkType, mimeType))
{
stream.Write(imageData, 0, imageData.Length);
return text;
}
}
public bool TryCreateObject(ObjectType objectType, out IPersistable persistObj)
{
switch (objectType)
{
case ObjectType.DataCellInstance:
persistObj = new DataCellInstance();
break;
case ObjectType.DataAggregateObjResult:
persistObj = new DataAggregateObjResult();
break;
case ObjectType.DataRegionMemberInstance:
persistObj = new DataRegionMemberInstance();
break;
case ObjectType.DataRegionInstance:
persistObj = new DataRegionInstance();
break;
case ObjectType.DataSetInstance:
persistObj = new DataSetInstance();
break;
case ObjectType.ReportInstance:
persistObj = new ReportInstance();
break;
case ObjectType.OnDemandMetadata:
persistObj = new OnDemandMetadata();
break;
case ObjectType.GroupTreePartition:
persistObj = new GroupTreePartition();
break;
case ObjectType.IntermediateFormatVersion:
persistObj = new IntermediateFormatVersion();
break;
case ObjectType.ReportSnapshot:
persistObj = new ReportSnapshot();
break;
case ObjectType.SubReportInstance:
persistObj = new SubReportInstance();
break;
case ObjectType.Parameters:
persistObj = new ParametersImplWrapper();
break;
case ObjectType.Parameter:
persistObj = new ParameterImplWrapper();
break;
case ObjectType.SubReportInfo:
persistObj = new SubReportInfo();
break;
case ObjectType.CommonSubReportInfo:
persistObj = new CommonSubReportInfo();
break;
case ObjectType.ParameterInfo:
persistObj = new ParameterInfo();
break;
case ObjectType.ParameterInfoCollection:
persistObj = new ParameterInfoCollection();
break;
case ObjectType.ParametersLayout:
persistObj = new ParametersGridLayout();
break;
case ObjectType.ParameterGridLayoutCellDefinition:
persistObj = new ParameterGridLayoutCellDefinition();
break;
case ObjectType.ValidValue:
persistObj = new ValidValue();
break;
case ObjectType.FieldInfo:
persistObj = new FieldInfo();
break;
case ObjectType.ImageInfo:
persistObj = new ImageInfo();
break;
case ObjectType.TreePartitionManager:
persistObj = new TreePartitionManager();
break;
case ObjectType.LookupObjResult:
persistObj = new LookupObjResult();
break;
case ObjectType.ShapefileInfo:
persistObj = new ShapefileInfo();
break;
case ObjectType.UpdatedVariableValues:
persistObj = new UpdatedVariableValues();
break;
case ObjectType.DataCellInstanceList:
persistObj = new DataCellInstanceList();
break;
default:
persistObj = null;
return(false);
}
return(true);
}
public ProcessReportOdpUserSort(IConfiguration configuration, ProcessingContext pc, Microsoft.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, OnDemandMetadata odpMetadataFromSnapshot, SortFilterEventInfoMap oldUserSortInformation, EventInformation newUserSortInformation, string oldUserSortEventSourceUniqueName)
: base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext, odpMetadataFromSnapshot)
{
m_oldUserSortInformation = oldUserSortInformation;
m_newUserSortInformation = newUserSortInformation;
m_oldUserSortEventSourceUniqueName = oldUserSortEventSourceUniqueName;
}
