public void Serialize(IntermediateFormatWriter writer)
{
writer.RegisterDeclaration(PageBreakProperties.m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.PageBreakAtStart:
writer.Write(this.m_pageBreakAtStart);
break;
case MemberName.PageBreakAtEnd:
writer.Write(this.m_pageBreakAtEnd);
break;
case MemberName.ResetPageNumber:
writer.Write(this.m_resetPageNumber);
break;
case MemberName.Source:
{
int value = scalabilityCache.StoreStaticReference(this.m_source);
writer.Write(value);
break;
}
default:
RSTrace.RenderingTracer.Assert(false, string.Empty);
break;
}
}
}
public override void Serialize(IntermediateFormatWriter writer)
{
writer.RegisterDeclaration(m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.ExpressionType:
writer.WriteEnum((int)m_expressionType);
break;
case MemberName.CurrentMin:
writer.Write(m_currentMin);
break;
case MemberName.Comparer:
{
int value = scalabilityCache.StoreStaticReference(m_comparer);
writer.Write(value);
break;
}
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
public void TransferTo(IScalabilityCache scaleCache)
{
for (int i = 0; i < Entries.Length; i++)
{
IScalableDictionaryEntry scalableDictionaryEntry = Entries[i];
if (scalableDictionaryEntry != null)
{
switch (scalableDictionaryEntry.GetObjectType())
{
case Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryNodeReference:
{
ScalableDictionaryNodeReference scalableDictionaryNodeReference = scalableDictionaryEntry as ScalableDictionaryNodeReference;
Entries[i] = (ScalableDictionaryNodeReference)scalableDictionaryNodeReference.TransferTo(scaleCache);
break;
}
case Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryValues:
(scalableDictionaryEntry as ScalableDictionaryValues).TransferTo(scaleCache);
break;
default:
Global.Tracer.Assert(condition: false, "Unknown ObjectType");
break;
}
}
}
}
public override void Deserialize(IntermediateFormatReader reader)
{
base.Deserialize(reader);
reader.RegisterDeclaration(ReportBody.m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.BodySource:
{
int id = reader.ReadInt32();
this.m_source = (Body)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.Width:
this.m_originalWidth = reader.ReadDouble();
break;
default:
RSTrace.RenderingTracer.Assert(false, string.Empty);
break;
}
}
}
public void TransferTo(IScalabilityCache scaleCache)
{
if (Array == null || Array.Length == 0)
{
return;
}
IReference reference = Array[0] as IReference;
if (reference != null)
{
Array[0] = reference.TransferTo(scaleCache);
for (int i = 1; i < Array.Length; i++)
{
reference = (Array[i] as IReference);
if (reference != null)
{
Array[i] = reference.TransferTo(scaleCache);
}
}
return;
}
ITransferable transferable = Array[0] as ITransferable;
if (transferable != null)
{
transferable.TransferTo(scaleCache);
for (int j = 1; j < Array.Length; j++)
{
(Array[j] as ITransferable)?.TransferTo(scaleCache);
}
}
}
public void TransferTo(IScalabilityCache scaleCache)
{
if (this.Array != null && this.Array.Length > 0)
{
IReference reference = this.Array[0] as IReference;
if (reference != null)
{
this.Array[0] = reference.TransferTo(scaleCache);
for (int i = 1; i < this.Array.Length; i++)
{
reference = (this.Array[i] as IReference);
if (reference != null)
{
this.Array[i] = reference.TransferTo(scaleCache);
}
}
}
else
{
ITransferable transferable = this.Array[0] as ITransferable;
if (transferable != null)
{
transferable.TransferTo(scaleCache);
for (int j = 1; j < this.Array.Length; j++)
{
transferable = (this.Array[j] as ITransferable);
if (transferable != null)
{
transferable.TransferTo(scaleCache);
}
}
}
}
}
}
public void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(PageBreakProperties.m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.PageBreakAtStart:
this.m_pageBreakAtStart = reader.ReadBoolean();
break;
case MemberName.PageBreakAtEnd:
this.m_pageBreakAtEnd = reader.ReadBoolean();
break;
case MemberName.ResetPageNumber:
this.m_resetPageNumber = reader.ReadBoolean();
break;
case MemberName.Source:
{
int id = reader.ReadInt32();
this.m_source = scalabilityCache.FetchStaticReference(id);
break;
}
default:
RSTrace.RenderingTracer.Assert(false, string.Empty);
break;
}
}
}
public virtual void TransferTo(IScalabilityCache scaleCache)
{
if (this.m_rowOffsets != null)
{
this.m_rowOffsets.TransferTo(scaleCache);
}
}
public void TransferTo(IScalabilityCache scaleCache)
{
for (int i = 0; i < m_count; i++)
{
(m_values[i] as ITransferable)?.TransferTo(scaleCache);
}
}
public virtual void Serialize(IntermediateFormatWriter writer)
{
writer.RegisterDeclaration(RuntimeDataRegionObj.m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.OdpContext:
{
int value = scalabilityCache.StoreStaticReference(this.m_odpContext);
writer.Write(value);
break;
}
case MemberName.ObjectType:
writer.WriteEnum((int)this.m_objectType);
break;
case MemberName.Depth:
writer.Write(this.m_depth);
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public virtual void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(RuntimeDataRegionObj.m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.OdpContext:
{
int id = reader.ReadInt32();
this.m_odpContext = (OnDemandProcessingContext)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.ObjectType:
this.m_objectType = (AspNetCore.ReportingServices.ReportProcessing.ObjectType)reader.ReadEnum();
break;
case MemberName.Depth:
this.m_depth = reader.ReadInt32();
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public override void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.ExpressionType:
m_expressionType = (Microsoft.ReportingServices.ReportProcessing.DataAggregate.DataTypeCode)reader.ReadEnum();
break;
case MemberName.CurrentMin:
m_currentMin = reader.ReadVariant();
break;
case MemberName.Comparer:
{
int id = reader.ReadInt32();
m_comparer = (Microsoft.ReportingServices.ReportProcessing.ReportProcessing.ProcessingComparer)scalabilityCache.FetchStaticReference(id);
break;
}
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
internal void InitCache()
{
if (m_scalabilityCache == null)
{
m_scalabilityCache = ScalabilityUtils.CreateCacheForTransientAllocations(m_createAndRegisterStream, "HPB", StorageObjectCreator.Instance, HPBReferenceCreator.Instance, ComponentType.Pagination, 1);
}
}
public override void Serialize(IntermediateFormatWriter writer)
{
base.Serialize(writer);
writer.RegisterDeclaration(ReportBody.m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.BodySource:
{
int value = scalabilityCache.StoreStaticReference(this.m_source);
writer.Write(value);
break;
}
case MemberName.Width:
writer.Write(this.m_originalWidth);
break;
default:
RSTrace.RenderingTracer.Assert(false, string.Empty);
break;
}
}
}
public void NextRow()
{
long streamOffset = this.m_odpContext.ReportObjectModel.FieldsImpl.StreamOffset;
int num = -1;
CommonRowCache tablixProcessingLookupRowCache = this.m_odpContext.TablixProcessingLookupRowCache;
if (this.m_mustBufferAllRows)
{
num = tablixProcessingLookupRowCache.AddRow(RuntimeDataTablixObj.SaveData(this.m_odpContext));
if (this.m_firstRowCacheIndex == -1)
{
this.m_firstRowCacheIndex = num;
}
}
IScalabilityCache tablixProcessingScalabilityCache = this.m_odpContext.TablixProcessingScalabilityCache;
for (int i = 0; i < this.m_dataSet.LookupDestinationInfos.Count; i++)
{
LookupDestinationInfo lookupDestinationInfo = this.m_dataSet.LookupDestinationInfos[i];
LookupObjResult lookupObjResult = this.m_dataSetInstance.LookupResults[i];
if (!lookupObjResult.ErrorOccured)
{
AspNetCore.ReportingServices.RdlExpressions.VariantResult variantResult = lookupDestinationInfo.EvaluateDestExpr(this.m_odpContext, lookupObjResult);
if (variantResult.ErrorOccurred)
{
lookupObjResult.DataFieldStatus = variantResult.FieldStatus;
}
else
{
object value = variantResult.Value;
LookupTable lookupTable = lookupObjResult.GetLookupTable(this.m_odpContext);
try
{
LookupMatches lookupMatches = default(LookupMatches);
IDisposable disposable = default(IDisposable);
if (!lookupTable.TryGetAndPinValue(value, out lookupMatches, out disposable))
{
lookupMatches = ((!lookupDestinationInfo.UsedInSameDataSetTablixProcessing) ? new LookupMatches() : new LookupMatchesWithRows());
disposable = lookupTable.AddAndPin(value, lookupMatches);
}
if (lookupDestinationInfo.IsMultiValue || !lookupMatches.HasRow)
{
lookupMatches.AddRow(streamOffset, num, tablixProcessingScalabilityCache);
}
disposable.Dispose();
}
catch (ReportProcessingException_SpatialTypeComparisonError reportProcessingException_SpatialTypeComparisonError)
{
throw new ReportProcessingException(this.m_lookupOwner.RegisterSpatialElementComparisonError(reportProcessingException_SpatialTypeComparisonError.Type));
}
}
}
}
if (!this.m_mustBufferAllRows)
{
this.m_lookupOwner.PostLookupNextRow();
}
}
public void Serialize(IntermediateFormatWriter writer)
{
writer.RegisterDeclaration(m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.ReportObjectModel:
{
int value2 = scalabilityCache.StoreStaticReference(m_reportOM);
writer.Write(value2);
break;
}
case MemberName.Value:
writer.WriteVariantOrPersistable(m_value);
break;
case MemberName.IsAggregateField:
writer.Write(m_isAggregationField);
break;
case MemberName.AggregationFieldChecked:
writer.Write(m_aggregationFieldChecked);
break;
case MemberName.FieldStatus:
writer.WriteEnum((int)m_fieldStatus);
break;
case MemberName.Message:
writer.Write(m_exceptionMessage);
break;
case MemberName.Properties:
writer.WriteStringObjectHashtable(m_properties);
break;
case MemberName.FieldDef:
{
int value = scalabilityCache.StoreStaticReference(m_fieldDef);
writer.Write(value);
break;
}
case MemberName.UsedInExpression:
writer.Write(m_usedInExpression);
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
public void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.ReportObjectModel:
{
int id2 = reader.ReadInt32();
m_reportOM = (ObjectModelImpl)scalabilityCache.FetchStaticReference(id2);
break;
}
case MemberName.Value:
m_value = reader.ReadVariant();
break;
case MemberName.IsAggregateField:
m_isAggregationField = reader.ReadBoolean();
break;
case MemberName.AggregationFieldChecked:
m_aggregationFieldChecked = reader.ReadBoolean();
break;
case MemberName.FieldStatus:
m_fieldStatus = (DataFieldStatus)reader.ReadEnum();
break;
case MemberName.Message:
m_exceptionMessage = reader.ReadString();
break;
case MemberName.Properties:
m_properties = reader.ReadStringObjectHashtable <Hashtable>();
break;
case MemberName.FieldDef:
{
int id = reader.ReadInt32();
m_fieldDef = (Microsoft.ReportingServices.ReportIntermediateFormat.Field)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.UsedInExpression:
m_usedInExpression = reader.ReadBoolean();
break;
default:
Global.Tracer.Assert(condition: false);
break;
}
}
}
public override void TransferTo(IScalabilityCache scaleCache)
{
base.TransferTo(scaleCache);
if (this.m_rows != null)
{
this.m_rows.Dispose();
this.m_rows = null;
}
this.m_hasBeenTransferred = true;
}
private void DisposeScalabilityCache()
{
if (m_scalabilityCache != null)
{
m_totalScaleTimeMs += m_scalabilityCache.ScalabilityDurationMs;
m_peakMemoryUsageKB = Math.Max(m_peakMemoryUsageKB, m_scalabilityCache.PeakMemoryUsageKBytes);
m_scalabilityCache.Dispose();
m_scalabilityCache = null;
}
}
public void Serialize(IntermediateFormatWriter writer)
{
writer.RegisterDeclaration(TextRun.m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.Text:
writer.Write(this.m_text);
break;
case MemberName.Style:
writer.WriteByteVariantHashtable(this.m_styles);
break;
case MemberName.ToolTip:
writer.Write(this.m_toolTip);
break;
case MemberName.MarkupType:
writer.Write(this.m_markup);
break;
case MemberName.Actions:
writer.WriteListOfPrimitives(this.m_hyperlinks);
break;
case MemberName.UniqueName:
writer.Write(this.m_uniqueName);
break;
case MemberName.Source:
writer.Write(scalabilityCache.StoreStaticReference(this.m_source));
break;
case MemberName.Indexes:
writer.WriteListOfPrimitives(this.m_splitIndices);
break;
case MemberName.Offset:
writer.Write(this.m_startCharacterOffset);
break;
case MemberName.Key:
writer.Write(this.m_fontKey);
break;
default:
RSTrace.RenderingTracer.Assert(false, string.Empty);
break;
}
}
}
public void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(TextRun.m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.Text:
this.m_text = reader.ReadString();
break;
case MemberName.Style:
this.m_styles = reader.ReadByteVariantHashtable <Dictionary <byte, object> >();
break;
case MemberName.ToolTip:
this.m_toolTip = reader.ReadString();
break;
case MemberName.MarkupType:
this.m_markup = (byte?)(object)(reader.ReadVariant() as byte?);
break;
case MemberName.Actions:
this.m_hyperlinks = reader.ReadListOfPrimitives <string>();
break;
case MemberName.UniqueName:
this.m_uniqueName = reader.ReadString();
break;
case MemberName.Source:
this.m_source = (AspNetCore.ReportingServices.OnDemandReportRendering.TextRun)scalabilityCache.FetchStaticReference(reader.ReadInt32());
break;
case MemberName.Indexes:
this.m_splitIndices = reader.ReadListOfPrimitives <int>();
break;
case MemberName.Offset:
this.m_startCharacterOffset = reader.ReadInt32();
break;
case MemberName.Key:
this.m_fontKey = reader.ReadString();
break;
default:
RSTrace.RenderingTracer.Assert(false, string.Empty);
break;
}
}
}
public override void Serialize(IntermediateFormatWriter writer)
{
writer.RegisterDeclaration(Previous.m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.OdpContext:
{
int value = scalabilityCache.StoreStaticReference(this.m_odpContext);
writer.Write(value);
break;
}
case MemberName.PreviousValues:
writer.WriteVariantListVariantDictionary(this.m_previousValues);
break;
case MemberName.Values:
writer.WriteVariantListVariantDictionary(this.m_values);
break;
case MemberName.StartHidden:
writer.Write(this.m_startIndex);
break;
case MemberName.IsScopedInEvaluationScope:
writer.Write(this.m_isScopedInEvaluationScope);
break;
case MemberName.Previous:
writer.Write(this.m_previous);
break;
case MemberName.PreviousEnabled:
writer.Write(this.m_previousEnabled);
break;
case MemberName.HasNoExplicitScope:
writer.Write(this.m_hasNoExplicitScope);
break;
case MemberName.Value:
writer.Write(this.m_value);
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public void Serialize(IntermediateFormatWriter writer)
{
writer.RegisterDeclaration(ScalableDictionary <TKey, TValue> .m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.NodeCapacity:
writer.Write(this.m_nodeCapacity);
break;
case MemberName.ValuesCapacity:
writer.Write(this.m_valuesCapacity);
break;
case MemberName.Comparer:
{
int value = -2147483648;
if (scalabilityCache.CacheType == ScalabilityCacheType.Standard)
{
value = scalabilityCache.StoreStaticReference(this.m_comparer);
}
writer.Write(value);
break;
}
case MemberName.Count:
writer.Write(this.m_count);
break;
case MemberName.Version:
writer.Write(this.m_version);
break;
case MemberName.Root:
writer.Write(this.m_root);
break;
case MemberName.UseFixedReferences:
writer.Write(this.m_useFixedReferences);
break;
case MemberName.Priority:
writer.Write(this.m_priority);
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public void TransferTo(IScalabilityCache scaleCache)
{
for (int i = 0; i < this.m_count; i++)
{
ITransferable transferable = this.m_values[i] as ITransferable;
if (transferable != null)
{
transferable.TransferTo(scaleCache);
}
}
}
public override void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(Previous.m_declaration);
IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.OdpContext:
{
int id = reader.ReadInt32();
this.m_odpContext = (OnDemandProcessingContext)scalabilityCache.FetchStaticReference(id);
break;
}
case MemberName.PreviousValues:
this.m_previousValues = reader.ReadVariantListVariantDictionary();
break;
case MemberName.Values:
this.m_values = reader.ReadVariantListVariantDictionary();
break;
case MemberName.StartHidden:
this.m_startIndex = reader.ReadInt32();
break;
case MemberName.IsScopedInEvaluationScope:
this.m_isScopedInEvaluationScope = reader.ReadBoolean();
break;
case MemberName.Previous:
this.m_previous = reader.ReadVariant();
break;
case MemberName.PreviousEnabled:
this.m_previousEnabled = reader.ReadBoolean();
break;
case MemberName.HasNoExplicitScope:
this.m_hasNoExplicitScope = reader.ReadBoolean();
break;
case MemberName.Value:
this.m_value = reader.ReadVariant();
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(ScalableDictionary <TKey, TValue> .m_declaration);
IScalabilityCache scalabilityCache = this.m_scalabilityCache = (reader.PersistenceHelper as IScalabilityCache);
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.NodeCapacity:
this.m_nodeCapacity = reader.ReadInt32();
break;
case MemberName.ValuesCapacity:
this.m_valuesCapacity = reader.ReadInt32();
break;
case MemberName.Comparer:
{
int id = reader.ReadInt32();
if (scalabilityCache.CacheType == ScalabilityCacheType.Standard)
{
this.m_comparer = (IEqualityComparer <TKey>)scalabilityCache.FetchStaticReference(id);
}
break;
}
case MemberName.Count:
this.m_count = reader.ReadInt32();
break;
case MemberName.Version:
this.m_version = reader.ReadInt32();
break;
case MemberName.Root:
this.m_root = (ScalableDictionaryNodeReference)reader.ReadRIFObject();
break;
case MemberName.UseFixedReferences:
this.m_useFixedReferences = reader.ReadBoolean();
break;
case MemberName.Priority:
this.m_priority = reader.ReadInt32();
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public void TransferTo(IScalabilityCache scaleCache)
{
if (this.m_array != null)
{
this.m_array = (IReference <StorableArray>) this.m_array.TransferTo(scaleCache);
}
else
{
this.m_buckets.TransferTo(scaleCache);
}
this.m_cache = scaleCache;
}
internal RIFAppendOnlyStorage(IStreamHandler streamHandler, IScalabilityObjectCreator appObjectCreator, IReferenceCreator appReferenceCreator, GlobalIDOwnerCollection globalIdsFromOtherStream, bool fromExistingStream, int rifCompatVersion, bool prohibitSerializableValues)
{
m_streamCreator = streamHandler;
m_scalabilityCache = null;
m_stream = null;
m_unifiedObjectCreator = new UnifiedObjectCreator(appObjectCreator, appReferenceCreator);
m_referenceCreator = new UnifiedReferenceCreator(appReferenceCreator);
m_fromExistingStream = fromExistingStream;
m_globalIdsFromOtherStream = globalIdsFromOtherStream;
m_prohibitSerializableValues = prohibitSerializableValues;
m_rifCompatVersion = rifCompatVersion;
}
public override void Serialize(IntermediateFormatWriter writer)
{
base.Serialize(writer);
writer.RegisterDeclaration(RuntimeDetailObj.m_declaration);
IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
while (writer.NextMember())
{
switch (writer.CurrentMember.MemberName)
{
case MemberName.OuterScope:
writer.Write(this.m_outerScope);
break;
case MemberName.DataRegionDef:
{
int value = scalabilityCache.StoreStaticReference(this.m_dataRegionDef);
writer.Write(value);
break;
}
case MemberName.DataRows:
writer.Write(this.m_dataRows);
break;
case MemberName.RunningValueValues:
writer.Write(this.m_rvValueList);
break;
case MemberName.RunningValuesInGroup:
writer.WriteListOfPrimitives(this.m_runningValuesInGroup);
break;
case MemberName.PreviousValuesInGroup:
writer.WriteListOfPrimitives(this.m_previousValuesInGroup);
break;
case MemberName.GroupCollection:
writer.Write(this.m_groupCollection);
break;
case MemberName.OuterDataAction:
writer.Write(this.m_outerDataAction);
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
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;
}
}
}
