예제 #1
0
        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 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;
                }
            }
        }
예제 #3
0
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.NonComputedReportItems:
                    m_nonComputedReportItems = reader.ReadGenericListOfRIFObjects <ReportItem>();
                    break;

                case MemberName.ComputedReportItems:
                    m_computedReportItems = reader.ReadGenericListOfRIFObjects <ReportItem>();
                    break;

                case MemberName.SortedReportItems:
                    m_sortedReportItemList = reader.ReadGenericListOfRIFObjects <ReportItemIndexer>();
                    break;

                case MemberName.ROMIndexMap:
                    m_romIndexMap = reader.ReadListOfPrimitives <int>();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #4
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(RecordField.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.FieldStatus:
                    this.m_fieldStatus = (DataFieldStatus)reader.ReadEnum();
                    break;

                case MemberName.FieldValue:
                    this.m_fieldValue = reader.ReadVariant();
                    break;

                case MemberName.FieldValueSerializable:
                    this.m_fieldValue = reader.ReadSerializable();
                    break;

                case MemberName.IsAggregateField:
                    this.m_isAggregationField = reader.ReadBoolean();
                    break;

                case MemberName.FieldPropertyValues:
                    this.m_fieldPropertyValues = reader.ReadListOfPrimitives <object>();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
예제 #5
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(RuntimeUserSortTargetInfo.m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.SortTree:
                    this.m_sortTree = (BTree)reader.ReadRIFObject();
                    break;

                case MemberName.AggregateRows:
                    this.m_aggregateRows = reader.ReadListOfRIFObjects <List <AggregateRow> >();
                    break;

                case MemberName.SortFilterInfoIndices:
                    this.m_sortFilterInfoIndices = reader.ReadListOfPrimitives <int>();
                    break;

                case MemberName.TargetForNonDetailSort:
                    this.m_targetForNonDetailSort = reader.ReadVariantVariantHashtable();
                    break;

                case MemberName.TargetForDetailSort:
                    this.m_targetForDetailSort = reader.ReadVariantVariantHashtable();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
예제 #6
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.DataSetName:
                    m_dataSetName = reader.ReadString();
                    break;

                case MemberName.Key:
                {
                    string item = reader.ReadString();
                    m_keyFields = new List <string>(1);
                    m_keyFields.Add(item);
                    break;
                }

                case MemberName.Label:
                    m_label = reader.ReadString();
                    break;

                case MemberName.KeyFields:
                    m_keyFields = reader.ReadListOfPrimitives <string>();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #7
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.AggregatesSpanGroupFilter:
                    m_aggregatesSpanGroupFilter = reader.ReadBoolean();
                    break;

                case MemberName.AggregatesOfAggregates:
                    m_aggregatesOfAggregates = (BucketedDataAggregateInfos)reader.ReadRIFObject();
                    break;

                case MemberName.PostSortAggregatesOfAggregates:
                    m_postSortAggregatesOfAggregates = (BucketedDataAggregateInfos)reader.ReadRIFObject();
                    break;

                case MemberName.RunningValuesOfAggregates:
                    m_runningValuesOfAggregates = reader.ReadGenericListOfRIFObjects <RunningValueInfo>();
                    break;

                case MemberName.ScopeID:
                    m_scopeID = reader.ReadInt32();
                    break;

                case MemberName.HasAggregatesToUpdateAtRowScope:
                    m_hasAggregatesToUpdateAtRowScope = reader.ReadBoolean();
                    break;

                case MemberName.IsDecomposable:
                    m_isDecomposable = reader.ReadBoolean();
                    break;

                case MemberName.DataSet:
                    m_dataSet = reader.ReadReference <DataSet>(this);
                    break;

                case MemberName.JoinInfo:
                    m_joinInfo = (JoinInfo)reader.ReadRIFObject();
                    break;

                case MemberName.DataPipelineID:
                    m_dataPipelineID = reader.ReadInt32();
                    break;

                case MemberName.GroupingFieldIndicesForServerAggregates:
                    m_groupingFieldIndicesForServerAggregates = reader.ReadListOfPrimitives <int>();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #8
0
        public virtual void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.FieldPropertyNames:
                    m_propertyNames = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.FieldPropertyReaderIndices:
                    m_propertyReaderIndices = reader.ReadListOfPrimitives <int>();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #9
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(Sorting.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.SortExpressions:
                    this.m_sortExpressions = reader.ReadGenericListOfRIFObjects <ExpressionInfo>();
                    break;

                case MemberName.SortDirections:
                    this.m_sortDirections = reader.ReadListOfPrimitives <bool>();
                    break;

                case MemberName.NaturalSortFlags:
                    this.m_naturalSortFlags = reader.ReadListOfPrimitives <bool>();
                    break;

                case MemberName.NaturalSort:
                    this.m_naturalSort = reader.ReadBoolean();
                    break;

                case MemberName.DeferredSortFlags:
                    this.m_deferredSortFlags = reader.ReadListOfPrimitives <bool>();
                    break;

                case MemberName.DeferredSort:
                    this.m_deferredSort = reader.ReadBoolean();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
예제 #10
0
 public void Deserialize(IntermediateFormatReader reader)
 {
     reader.RegisterDeclaration(TreePartitionManager.m_Declaration);
     while (reader.NextMember())
     {
         MemberName memberName = reader.CurrentMember.MemberName;
         if (memberName == MemberName.TreePartitionOffsets)
         {
             this.m_treePartitionOffsets = reader.ReadListOfPrimitives <long>();
         }
         else
         {
             Global.Tracer.Assert(false);
         }
     }
 }
 public void Deserialize(IntermediateFormatReader reader)
 {
     reader.RegisterDeclaration(m_Declaration);
     while (reader.NextMember())
     {
         MemberName memberName = reader.CurrentMember.MemberName;
         if (memberName == MemberName.PropertyNames)
         {
             m_propertyNames = reader.ReadListOfPrimitives <string>();
         }
         else
         {
             Global.Tracer.Assert(condition: false);
         }
     }
 }
예제 #12
0
 public override void Deserialize(IntermediateFormatReader reader)
 {
     base.Deserialize(reader);
     reader.RegisterDeclaration(GetDeclaration());
     while (reader.NextMember())
     {
         MemberName memberName = reader.CurrentMember.MemberName;
         if (memberName == MemberName.Columns)
         {
             _columns = reader.ReadListOfPrimitives <int>();
         }
         else
         {
             WordOpenXmlUtils.FailSerializable();
         }
     }
 }
예제 #13
0
        public virtual void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(DataAggregateInfo.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    this.m_name = reader.ReadString();
                    break;

                case MemberName.AggregateType:
                    this.m_aggregateType = (AggregateTypes)reader.ReadEnum();
                    break;

                case MemberName.Expressions:
                    this.m_expressions = reader.ReadArrayOfRIFObjects <ExpressionInfo>();
                    break;

                case MemberName.DuplicateNames:
                    this.m_duplicateNames = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.DataSetIndexInCollection:
                    this.m_dataSetIndexInCollection = reader.ReadInt32();
                    break;

                case MemberName.UpdateScopeID:
                    this.m_updateScopeID = reader.ReadInt32();
                    break;

                case MemberName.UpdateScopeDepth:
                    this.m_updateScopeDepth = reader.ReadInt32();
                    break;

                case MemberName.UpdatesAtRowScope:
                    this.m_updatesAtRowScope = reader.ReadBoolean();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
예제 #14
0
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.HasStaticMembers:
                    m_hasStaticMembers = reader.ReadBoolean();
                    break;

                case MemberName.StaticLeafCellIndexes:
                    m_staticLeafCellIndexes = reader.ReadListOfPrimitives <int>();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #15
0
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.InnerGroupings:
                    m_innerGroupings = reader.ReadArrayOfRIFObjects <IReference <RuntimeMemberObj> >();
                    break;

                case MemberName.CellRunningValues:
                    m_cellRVs = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.StaticCellRunningValues:
                    m_staticCellRVs = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.CellPreviousValues:
                    m_cellPreviousValues = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.StaticCellPreviousValues:
                    m_staticCellPreviousValues = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.HeadingLevel:
                    m_headingLevel = reader.ReadInt32();
                    break;

                case MemberName.OutermostStatics:
                    m_outermostStatics = reader.ReadBoolean();
                    break;

                case MemberName.HasLeafCells:
                    m_hasLeafCells = reader.ReadBoolean();
                    break;

                case MemberName.ProcessOutermostStaticCells:
                    m_processOutermostStaticCells = reader.ReadBoolean();
                    break;

                case MemberName.CurrentMemberIndexWithinScopeLevel:
                    m_currentMemberIndexWithinScopeLevel = reader.ReadInt32();
                    break;

                case MemberName.RecursiveParentIndexes:
                    m_recursiveParentIndexes = reader.ReadListOfPrimitives <int>();
                    break;

                case MemberName.ProcessStaticCellsForRVs:
                    m_processStaticCellsForRVs = reader.ReadBoolean();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #16
0
        internal override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_Declaration);
            ReportItem    reportItem           = (ReportItem)base.ReportElementDef;
            List <string> customPropertyNames  = null;
            List <object> customPropertyValues = null;

            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.ToolTip:
                {
                    string text3 = reader.ReadString();
                    if (reportItem.ToolTip.IsExpression)
                    {
                        m_toolTip = text3;
                    }
                    else
                    {
                        Global.Tracer.Assert(text3 == null, "(toolTip == null)");
                    }
                    break;
                }

                case MemberName.Bookmark:
                {
                    string text2 = reader.ReadString();
                    if (reportItem.Bookmark.IsExpression)
                    {
                        m_bookmark = text2;
                    }
                    else
                    {
                        Global.Tracer.Assert(text2 == null, "(bookmark == null)");
                    }
                    break;
                }

                case MemberName.Label:
                {
                    string text = reader.ReadString();
                    if (reportItem.DocumentMapLabel.IsExpression)
                    {
                        m_documentMapLabel = text;
                    }
                    else
                    {
                        Global.Tracer.Assert(text == null, "(documentMapLabel == null)");
                    }
                    break;
                }

                case MemberName.CustomPropertyNames:
                    customPropertyNames = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.CustomPropertyValues:
                    customPropertyValues = reader.ReadListOfPrimitives <object>();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
            reportItem.CustomProperties.SetDynamicValues(customPropertyNames, customPropertyValues);
        }
예제 #17
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    m_name = reader.ReadString();
                    break;

                case MemberName.ID:
                    m_ID = reader.ReadInt32();
                    break;

                case MemberName.GroupExpressions:
                    m_groupExpressions = reader.ReadGenericListOfRIFObjects <ExpressionInfo>();
                    break;

                case MemberName.GroupLabel:
                    m_groupLabel = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.SortDirections:
                    m_sortDirections = reader.ReadListOfPrimitives <bool>();
                    break;

                case MemberName.PageBreakLocation:
                    m_pageBreak = new PageBreak();
                    m_pageBreak.BreakLocation = (PageBreakLocation)reader.ReadEnum();
                    break;

                case MemberName.Aggregates:
                    m_aggregates = reader.ReadGenericListOfRIFObjects <DataAggregateInfo>();
                    break;

                case MemberName.GroupAndSort:
                    m_groupAndSort = reader.ReadBoolean();
                    break;

                case MemberName.Filters:
                    m_filters = reader.ReadGenericListOfRIFObjects <Filter>();
                    break;

                case MemberName.ReportItemsWithHideDuplicates:
                    m_reportItemsWithHideDuplicates = reader.ReadGenericListOfReferences <ReportItem>(this);
                    break;

                case MemberName.Parent:
                    m_parent = reader.ReadGenericListOfRIFObjects <ExpressionInfo>();
                    break;

                case MemberName.RecursiveAggregates:
                    m_recursiveAggregates = reader.ReadGenericListOfRIFObjects <DataAggregateInfo>();
                    break;

                case MemberName.PostSortAggregates:
                    m_postSortAggregates = reader.ReadGenericListOfRIFObjects <DataAggregateInfo>();
                    break;

                case MemberName.DataElementName:
                    m_dataElementName = reader.ReadString();
                    break;

                case MemberName.DataElementOutput:
                    m_dataElementOutput = (DataElementOutputTypes)reader.ReadEnum();
                    break;

                case MemberName.SaveGroupExprValues:
                    m_saveGroupExprValues = reader.ReadBoolean();
                    break;

                case MemberName.UserSortExpressions:
                    m_userSortExpressions = reader.ReadGenericListOfRIFObjects <ExpressionInfo>();
                    break;

                case MemberName.NonDetailSortFiltersInScope:
                    m_nonDetailSortFiltersInScope = reader.ReadInt32PrimitiveListHashtable <InScopeSortFilterHashtable, int>();
                    break;

                case MemberName.DetailSortFiltersInScope:
                    m_detailSortFiltersInScope = reader.ReadInt32PrimitiveListHashtable <InScopeSortFilterHashtable, int>();
                    break;

                case MemberName.Variables:
                    m_variables = reader.ReadGenericListOfRIFObjects <Variable>();
                    break;

                case MemberName.PageBreak:
                    m_pageBreak = (PageBreak)reader.ReadRIFObject();
                    break;

                case MemberName.PageName:
                    m_pageName = (ExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.DomainScope:
                    m_domainScope = reader.ReadString();
                    break;

                case MemberName.ScopeIDForDomainScope:
                    m_scopeIDForDomainScope = reader.ReadInt32();
                    break;

                case MemberName.NaturalGroup:
                    m_naturalGroup = reader.ReadBoolean();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #18
0
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;

            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.HierarchyDef:
                {
                    int id2 = reader.ReadInt32();
                    m_hierarchyDef = (Microsoft.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode)scalabilityCache.FetchStaticReference(id2);
                    break;
                }

                case MemberName.OuterScope:
                    m_outerScope = (IReference <IScope>)reader.ReadRIFObject();
                    break;

                case MemberName.ProcessingStage:
                    m_processingStage = (ProcessingStages)reader.ReadEnum();
                    break;

                case MemberName.ScopedRunningValues:
                    m_scopedRunningValues = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.RunningValuesInGroup:
                    m_runningValuesInGroup = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.PreviousValuesInGroup:
                    m_previousValuesInGroup = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.GroupCollection:
                    m_groupCollection = reader.ReadStringRIFObjectDictionary <IReference <RuntimeGroupRootObj> >();
                    break;

                case MemberName.DataAction:
                    m_dataAction = (DataActions)reader.ReadEnum();
                    break;

                case MemberName.OuterDataAction:
                    m_outerDataAction = (DataActions)reader.ReadEnum();
                    break;

                case MemberName.GroupingType:
                    m_groupingType = (RuntimeGroupingObj.GroupingTypes)reader.ReadEnum();
                    break;

                case MemberName.Filters:
                {
                    int id = reader.ReadInt32();
                    m_groupFilters = (Filters)scalabilityCache.FetchStaticReference(id);
                    break;
                }

                case MemberName.ParentExpression:
                    m_parentExpression = (RuntimeExpressionInfo)reader.ReadRIFObject();
                    break;

                case MemberName.CurrentGroupExprValue:
                    m_currentGroupExprValue = reader.ReadVariant();
                    break;

                case MemberName.SaveGroupExprValues:
                    m_saveGroupExprValues = reader.ReadBoolean();
                    break;

                case MemberName.SortFilterExpressionScopeInfoIndices:
                    m_sortFilterExpressionScopeInfoIndices = reader.ReadInt32Array();
                    break;

                case MemberName.BuiltinSortOverridden:
                    m_builtinSortOverridden = reader.ReadBooleanArray();
                    break;

                case MemberName.IsDetailGroup:
                    m_isDetailGroup = reader.ReadBoolean();
                    break;

                case MemberName.DetailUserSortTargetInfo:
                    m_detailUserSortTargetInfo = (RuntimeUserSortTargetInfo)reader.ReadRIFObject();
                    break;

                case MemberName.DetailRows:
                    m_detailDataRows = reader.ReadRIFObject <ScalableList <DataFieldRow> >();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
예제 #19
0
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(Cell.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.ExprHostID:
                    this.m_exprHostID = reader.ReadInt32();
                    break;

                case MemberName.ParentRowID:
                    base.m_parentIDOwner = reader.ReadReference <IDOwner>(this);
                    if (base.m_parentIDOwner != null)
                    {
                        this.m_parentRowID = base.m_parentIDOwner.ID;
                    }
                    break;

                case MemberName.ParentColumnID:
                    this.m_parentColumnIDOwner = reader.ReadReference <IDOwner>(this);
                    if (this.m_parentColumnIDOwner != null)
                    {
                        this.m_parentColumnID = this.m_parentColumnIDOwner.ID;
                    }
                    break;

                case MemberName.IndexInCollection:
                    this.m_indexInCollection = reader.ReadInt32();
                    break;

                case MemberName.HasInnerGroupTreeHierarchy:
                    this.m_hasInnerGroupTreeHierarchy = reader.ReadBoolean();
                    break;

                case MemberName.DataRegionDef:
                    this.m_dataRegionDef = reader.ReadReference <DataRegion>(this);
                    break;

                case MemberName.AggregateIndexes:
                    this.m_aggregateIndexes = reader.ReadListOfPrimitives <int>();
                    break;

                case MemberName.PostSortAggregateIndexes:
                    this.m_postSortAggregateIndexes = reader.ReadListOfPrimitives <int>();
                    break;

                case MemberName.RunningValueIndexes:
                    this.m_runningValueIndexes = reader.ReadListOfPrimitives <int>();
                    break;

                case MemberName.NeedToCacheDataRows:
                    this.m_needToCacheDataRows = reader.ReadBoolean();
                    break;

                case MemberName.InScopeEventSources:
                    this.m_inScopeEventSources = reader.ReadGenericListOfReferences <IInScopeEventSource>(this);
                    break;

                case MemberName.InDynamicRowAndColumnContext:
                    this.m_inDynamicRowAndColumnContext = reader.ReadBoolean();
                    break;

                case MemberName.TextboxesInScope:
                    this.m_textboxesInScope = reader.ReadByteArray();
                    break;

                case MemberName.VariablesInScope:
                    this.m_variablesInScope = reader.ReadByteArray();
                    break;

                case MemberName.DataScopeInfo:
                    this.m_dataScopeInfo = reader.ReadRIFObject <DataScopeInfo>();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
 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;
         }
     }
 }
        public virtual void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(OnDemandMetadata.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.CommonSubReportInfos:
                    this.m_commonSubReportInfoMap = reader.ReadStringRIFObjectDictionary <CommonSubReportInfo>();
                    break;

                case MemberName.SubReportInfos:
                    this.m_subReportInfoMap = reader.ReadStringRIFObjectDictionary <SubReportInfo>();
                    break;

                case MemberName.ReportSnapshot:
                    this.m_reportSnapshot = (AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot)reader.ReadRIFObject();
                    break;

                case MemberName.GroupTreePartitionOffsets:
                {
                    List <long> list = reader.ReadListOfPrimitives <long>();
                    if (list != null)
                    {
                        this.m_groupTreePartitions = new TreePartitionManager(list);
                    }
                    break;
                }

                case MemberName.DataChunkMap:
                    this.m_dataChunkMap = reader.ReadStringRIFObjectDictionary <DataSetInstance>();
                    break;

                case MemberName.CachedExternalImages:
                    this.m_cachedExternalImages = reader.ReadStringRIFObjectDictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.ImageInfo>();
                    break;

                case MemberName.CachedShapefiles:
                    this.m_cachedShapefiles = reader.ReadStringRIFObjectDictionary <ShapefileInfo>();
                    break;

                case MemberName.TransparentImageChunkName:
                    this.m_transparentImageChunkName = reader.ReadString();
                    break;

                case MemberName.GroupTreeRootOffset:
                    this.m_groupTreeRootOffset = reader.ReadInt64();
                    break;

                case MemberName.TablixProcessingComplete:
                    this.m_tablixProcessingComplete = reader.ReadStringBoolArrayDictionary();
                    break;

                case MemberName.GroupTreePartitions:
                    this.m_groupTreePartitions = (TreePartitionManager)reader.ReadRIFObject();
                    break;

                case MemberName.LookupPartitions:
                    this.m_lookupPartitions = (TreePartitionManager)reader.ReadRIFObject();
                    break;

                case MemberName.LastAssignedGlobalID:
                    this.m_lastAssignedGlobalID = reader.ReadInt32();
                    break;

                case MemberName.UpdatedVariableValues:
                    this.m_updatedVariableValues = reader.ReadStringRIFObjectDictionary <UpdatedVariableValues>();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }