Пример #1
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(ReportItemInstance.m_Declaration);
            ReportItem    reportItem = (ReportItem)base.ReportElementDef;
            List <string> list       = default(List <string>);
            List <object> list2      = default(List <object>);

            reportItem.CustomProperties.GetDynamicValues(out list, out list2);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ToolTip:
                {
                    string value2 = null;
                    if (reportItem.ToolTip.IsExpression)
                    {
                        value2 = this.m_toolTip;
                    }
                    writer.Write(value2);
                    break;
                }

                case MemberName.Bookmark:
                {
                    string value3 = null;
                    if (reportItem.Bookmark.IsExpression)
                    {
                        value3 = this.m_bookmark;
                    }
                    writer.Write(value3);
                    break;
                }

                case MemberName.Label:
                {
                    string value = null;
                    if (reportItem.DocumentMapLabel.IsExpression)
                    {
                        value = this.m_documentMapLabel;
                    }
                    writer.Write(value);
                    break;
                }

                case MemberName.CustomPropertyNames:
                    writer.WriteListOfPrimitives(list);
                    break;

                case MemberName.CustomPropertyValues:
                    writer.WriteListOfPrimitives(list2);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Пример #2
0
        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 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;
                }
            }
        }
Пример #4
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.NonComputedReportItems:
                    writer.Write(m_nonComputedReportItems);
                    break;

                case MemberName.ComputedReportItems:
                    writer.Write(m_computedReportItems);
                    break;

                case MemberName.SortedReportItems:
                    writer.Write(m_sortedReportItemList);
                    break;

                case MemberName.ROMIndexMap:
                    writer.WriteListOfPrimitives(m_romIndexMap);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Пример #5
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(RecordField.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.FieldStatus:
                    writer.WriteEnum((int)this.m_fieldStatus);
                    break;

                case MemberName.FieldValueSerializable:
                    if (!writer.TryWriteSerializable(this.m_fieldValue))
                    {
                        this.m_fieldValue = null;
                        writer.WriteNull();
                        this.m_fieldStatus = DataFieldStatus.UnSupportedDataType;
                    }
                    break;

                case MemberName.IsAggregateField:
                    writer.Write(this.m_isAggregationField);
                    break;

                case MemberName.FieldPropertyValues:
                    writer.WriteListOfPrimitives(this.m_fieldPropertyValues);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Пример #6
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(RuntimeUserSortTargetInfo.m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.SortTree:
                    writer.Write(this.m_sortTree);
                    break;

                case MemberName.AggregateRows:
                    writer.Write(this.m_aggregateRows);
                    break;

                case MemberName.SortFilterInfoIndices:
                    writer.WriteListOfPrimitives(this.m_sortFilterInfoIndices);
                    break;

                case MemberName.TargetForNonDetailSort:
                    writer.WriteVariantVariantHashtable(this.m_targetForNonDetailSort);
                    break;

                case MemberName.TargetForDetailSort:
                    writer.WriteVariantVariantHashtable(this.m_targetForDetailSort);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Пример #7
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataSetName:
                    writer.Write(m_dataSetName);
                    break;

                case MemberName.Key:
                    writer.Write(m_keyFields[0]);
                    break;

                case MemberName.Label:
                    writer.Write(m_label);
                    break;

                case MemberName.KeyFields:
                    writer.WriteListOfPrimitives(m_keyFields);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Пример #8
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.AggregatesSpanGroupFilter:
                    writer.Write(m_aggregatesSpanGroupFilter);
                    break;

                case MemberName.AggregatesOfAggregates:
                    writer.Write(m_aggregatesOfAggregates);
                    break;

                case MemberName.PostSortAggregatesOfAggregates:
                    writer.Write(m_postSortAggregatesOfAggregates);
                    break;

                case MemberName.RunningValuesOfAggregates:
                    writer.Write(m_runningValuesOfAggregates);
                    break;

                case MemberName.ScopeID:
                    writer.Write(m_scopeID);
                    break;

                case MemberName.HasAggregatesToUpdateAtRowScope:
                    writer.Write(m_hasAggregatesToUpdateAtRowScope);
                    break;

                case MemberName.IsDecomposable:
                    writer.Write(m_isDecomposable);
                    break;

                case MemberName.DataSet:
                    writer.WriteReference(m_dataSet);
                    break;

                case MemberName.JoinInfo:
                    writer.Write(m_joinInfo);
                    break;

                case MemberName.DataPipelineID:
                    writer.Write(m_dataPipelineID);
                    break;

                case MemberName.GroupingFieldIndicesForServerAggregates:
                    writer.WriteListOfPrimitives(m_groupingFieldIndicesForServerAggregates);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Пример #9
0
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.FieldPropertyNames:
                    writer.WriteListOfPrimitives(m_propertyNames);
                    break;

                case MemberName.FieldPropertyReaderIndices:
                    writer.WriteListOfPrimitives(m_propertyReaderIndices);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Пример #10
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(Sorting.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.SortExpressions:
                    writer.Write(this.m_sortExpressions);
                    break;

                case MemberName.SortDirections:
                    writer.WriteListOfPrimitives(this.m_sortDirections);
                    break;

                case MemberName.NaturalSortFlags:
                    writer.WriteListOfPrimitives(this.m_naturalSortFlags);
                    break;

                case MemberName.NaturalSort:
                    writer.Write(this.m_naturalSort);
                    break;

                case MemberName.DeferredSortFlags:
                    writer.WriteListOfPrimitives(this.m_deferredSortFlags);
                    break;

                case MemberName.DeferredSort:
                    writer.Write(this.m_deferredSort);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
 public void Serialize(IntermediateFormatWriter writer)
 {
     writer.RegisterDeclaration(m_Declaration);
     while (writer.NextMember())
     {
         MemberName memberName = writer.CurrentMember.MemberName;
         if (memberName == MemberName.PropertyNames)
         {
             writer.WriteListOfPrimitives(m_propertyNames);
         }
         else
         {
             Global.Tracer.Assert(condition: false);
         }
     }
 }
Пример #12
0
 public void Serialize(IntermediateFormatWriter writer)
 {
     writer.RegisterDeclaration(TreePartitionManager.m_Declaration);
     while (writer.NextMember())
     {
         MemberName memberName = writer.CurrentMember.MemberName;
         if (memberName == MemberName.TreePartitionOffsets)
         {
             writer.WriteListOfPrimitives(this.m_treePartitionOffsets);
         }
         else
         {
             Global.Tracer.Assert(false);
         }
     }
 }
Пример #13
0
 public override void Serialize(IntermediateFormatWriter writer)
 {
     base.Serialize(writer);
     writer.RegisterDeclaration(GetDeclaration());
     while (writer.NextMember())
     {
         MemberName memberName = writer.CurrentMember.MemberName;
         if (memberName == MemberName.Columns)
         {
             writer.WriteListOfPrimitives(_columns);
         }
         else
         {
             WordOpenXmlUtils.FailSerializable();
         }
     }
 }
Пример #14
0
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(DataAggregateInfo.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.AggregateType:
                    writer.WriteEnum((int)this.m_aggregateType);
                    break;

                case MemberName.Expressions:
                    writer.Write(this.m_expressions);
                    break;

                case MemberName.DuplicateNames:
                    writer.WriteListOfPrimitives(this.m_duplicateNames);
                    break;

                case MemberName.DataSetIndexInCollection:
                    writer.Write(this.m_dataSetIndexInCollection);
                    break;

                case MemberName.UpdateScopeID:
                    writer.Write(this.m_updateScopeID);
                    break;

                case MemberName.UpdateScopeDepth:
                    writer.Write(this.m_updateScopeDepth);
                    break;

                case MemberName.UpdatesAtRowScope:
                    writer.Write(this.m_updatesAtRowScope);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Пример #15
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.HasStaticMembers:
                    writer.Write(m_hasStaticMembers);
                    break;

                case MemberName.StaticLeafCellIndexes:
                    writer.WriteListOfPrimitives(m_staticLeafCellIndexes);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
 public override void Serialize(IntermediateFormatWriter writer)
 {
     base.Serialize(writer);
     writer.RegisterDeclaration(m_declaration);
     IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;
     while (writer.NextMember())
     {
         switch (writer.CurrentMember.MemberName)
         {
         case MemberName.DataRegionDef:
         {
             int value2 = scalabilityCache.StoreStaticReference(m_dataRegionDef);
             writer.Write(value2);
             break;
         }
         case MemberName.OuterScope:
             writer.Write(m_outerScope);
             break;
         case MemberName.FirstRow:
             writer.Write(m_firstRow);
             break;
         case MemberName.FirstRowIsAggregate:
             writer.Write(m_firstRowIsAggregate);
             break;
         case MemberName.Filters:
         {
             int value = scalabilityCache.StoreStaticReference(m_filters);
             writer.Write(value);
             break;
         }
         case MemberName.NonCustomAggregates:
             writer.Write(m_nonCustomAggregates);
             break;
         case MemberName.CustomAggregates:
             writer.Write(m_customAggregates);
             break;
         case MemberName.DataAction:
             writer.WriteEnum((int)m_dataAction);
             break;
         case MemberName.OuterDataAction:
             writer.WriteEnum((int)m_outerDataAction);
             break;
         case MemberName.RunningValues:
             writer.WriteListOfPrimitives(m_runningValues);
             break;
         case MemberName.PreviousValues:
             writer.WriteListOfPrimitives(m_previousValues);
             break;
         case MemberName.RunningValueValues:
             writer.Write(m_runningValueValues);
             break;
         case MemberName.RunningValueOfAggregateValues:
             writer.Write(m_runningValueOfAggregateValues);
             break;
         case MemberName.PostSortAggregates:
             writer.Write(m_postSortAggregates);
             break;
         case MemberName.DataRows:
             writer.Write(m_dataRows);
             break;
         case MemberName.InnerDataAction:
             writer.WriteEnum((int)m_innerDataAction);
             break;
         case MemberName.UserSortTargetInfo:
             writer.Write(m_userSortTargetInfo);
             break;
         case MemberName.SortFilterExpressionScopeInfoIndices:
             writer.Write(m_sortFilterExpressionScopeInfoIndices);
             break;
         case MemberName.InDataRowSortPhase:
             writer.Write(m_inDataRowSortPhase);
             break;
         case MemberName.SortedDataRowTree:
             writer.Write(m_sortedDataRowTree);
             break;
         case MemberName.DataRowSortExpression:
             writer.Write(m_dataRowSortExpression);
             break;
         case MemberName.AggregatesOfAggregates:
             writer.Write(m_aggregatesOfAggregates);
             break;
         case MemberName.PostSortAggregatesOfAggregates:
             writer.Write(m_postSortAggregatesOfAggregates);
             break;
         case MemberName.HasProcessedAggregateRow:
             writer.Write(m_hasProcessedAggregateRow);
             break;
         default:
             Global.Tracer.Assert(condition: false);
             break;
         }
     }
 }
Пример #17
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(Cell.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                case MemberName.ParentRowID:
                    writer.WriteReferenceID(this.m_parentRowID);
                    break;

                case MemberName.ParentColumnID:
                    writer.WriteReferenceID(this.m_parentColumnID);
                    break;

                case MemberName.IndexInCollection:
                    writer.Write(this.m_indexInCollection);
                    break;

                case MemberName.HasInnerGroupTreeHierarchy:
                    writer.Write(this.m_hasInnerGroupTreeHierarchy);
                    break;

                case MemberName.DataRegionDef:
                    Global.Tracer.Assert(null != this.m_dataRegionDef, "(null != m_dataRegionDef)");
                    writer.WriteReference(this.m_dataRegionDef);
                    break;

                case MemberName.AggregateIndexes:
                    writer.WriteListOfPrimitives(this.m_aggregateIndexes);
                    break;

                case MemberName.PostSortAggregateIndexes:
                    writer.WriteListOfPrimitives(this.m_postSortAggregateIndexes);
                    break;

                case MemberName.RunningValueIndexes:
                    writer.WriteListOfPrimitives(this.m_runningValueIndexes);
                    break;

                case MemberName.NeedToCacheDataRows:
                    writer.Write(this.m_needToCacheDataRows);
                    break;

                case MemberName.InScopeEventSources:
                    writer.WriteListOfReferences(this.m_inScopeEventSources);
                    break;

                case MemberName.InDynamicRowAndColumnContext:
                    writer.Write(this.m_inDynamicRowAndColumnContext);
                    break;

                case MemberName.TextboxesInScope:
                    writer.Write(this.m_textboxesInScope);
                    break;

                case MemberName.VariablesInScope:
                    writer.Write(this.m_variablesInScope);
                    break;

                case MemberName.DataScopeInfo:
                    writer.Write(this.m_dataScopeInfo);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Пример #18
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.InnerGroupings:
                    writer.Write(m_innerGroupings);
                    break;

                case MemberName.CellRunningValues:
                    writer.WriteListOfPrimitives(m_cellRVs);
                    break;

                case MemberName.StaticCellRunningValues:
                    writer.WriteListOfPrimitives(m_staticCellRVs);
                    break;

                case MemberName.CellPreviousValues:
                    writer.WriteListOfPrimitives(m_cellPreviousValues);
                    break;

                case MemberName.StaticCellPreviousValues:
                    writer.WriteListOfPrimitives(m_staticCellPreviousValues);
                    break;

                case MemberName.HeadingLevel:
                    writer.Write(m_headingLevel);
                    break;

                case MemberName.OutermostStatics:
                    writer.Write(m_outermostStatics);
                    break;

                case MemberName.HasLeafCells:
                    writer.Write(m_hasLeafCells);
                    break;

                case MemberName.ProcessOutermostStaticCells:
                    writer.Write(m_processOutermostStaticCells);
                    break;

                case MemberName.CurrentMemberIndexWithinScopeLevel:
                    writer.Write(m_currentMemberIndexWithinScopeLevel);
                    break;

                case MemberName.RecursiveParentIndexes:
                    writer.WriteListOfPrimitives(m_recursiveParentIndexes);
                    break;

                case MemberName.ProcessStaticCellsForRVs:
                    writer.Write(m_processStaticCellsForRVs);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Пример #19
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(m_name);
                    break;

                case MemberName.ID:
                    writer.Write(m_ID);
                    break;

                case MemberName.GroupExpressions:
                    writer.Write(m_groupExpressions);
                    break;

                case MemberName.GroupLabel:
                    writer.Write(m_groupLabel);
                    break;

                case MemberName.SortDirections:
                    writer.WriteListOfPrimitives(m_sortDirections);
                    break;

                case MemberName.Aggregates:
                    writer.Write(m_aggregates);
                    break;

                case MemberName.GroupAndSort:
                    writer.Write(m_groupAndSort);
                    break;

                case MemberName.Filters:
                    writer.Write(m_filters);
                    break;

                case MemberName.ReportItemsWithHideDuplicates:
                    writer.WriteListOfReferences(m_reportItemsWithHideDuplicates);
                    break;

                case MemberName.Parent:
                    writer.Write(m_parent);
                    break;

                case MemberName.RecursiveAggregates:
                    writer.Write(m_recursiveAggregates);
                    break;

                case MemberName.PostSortAggregates:
                    writer.Write(m_postSortAggregates);
                    break;

                case MemberName.DataElementName:
                    writer.Write(m_dataElementName);
                    break;

                case MemberName.DataElementOutput:
                    writer.WriteEnum((int)m_dataElementOutput);
                    break;

                case MemberName.SaveGroupExprValues:
                    writer.Write(m_saveGroupExprValues);
                    break;

                case MemberName.UserSortExpressions:
                    writer.Write(m_userSortExpressions);
                    break;

                case MemberName.NonDetailSortFiltersInScope:
                    writer.WriteInt32PrimitiveListHashtable <int>(m_nonDetailSortFiltersInScope);
                    break;

                case MemberName.DetailSortFiltersInScope:
                    writer.WriteInt32PrimitiveListHashtable <int>(m_detailSortFiltersInScope);
                    break;

                case MemberName.Variables:
                    writer.Write(m_variables);
                    break;

                case MemberName.PageBreak:
                    writer.Write(m_pageBreak);
                    break;

                case MemberName.PageName:
                    writer.Write(m_pageName);
                    break;

                case MemberName.DomainScope:
                    writer.Write(m_domainScope);
                    break;

                case MemberName.ScopeIDForDomainScope:
                    writer.Write(m_scopeIDForDomainScope);
                    break;

                case MemberName.NaturalGroup:
                    writer.Write(m_naturalGroup);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Пример #20
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;

            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.HierarchyDef:
                {
                    int value2 = scalabilityCache.StoreStaticReference(m_hierarchyDef);
                    writer.Write(value2);
                    break;
                }

                case MemberName.OuterScope:
                    writer.Write(m_outerScope);
                    break;

                case MemberName.ProcessingStage:
                    writer.WriteEnum((int)m_processingStage);
                    break;

                case MemberName.ScopedRunningValues:
                    writer.WriteListOfPrimitives(m_scopedRunningValues);
                    break;

                case MemberName.RunningValuesInGroup:
                    writer.WriteListOfPrimitives(m_runningValuesInGroup);
                    break;

                case MemberName.PreviousValuesInGroup:
                    writer.WriteListOfPrimitives(m_previousValuesInGroup);
                    break;

                case MemberName.GroupCollection:
                    writer.WriteStringRIFObjectDictionary(m_groupCollection);
                    break;

                case MemberName.DataAction:
                    writer.WriteEnum((int)m_dataAction);
                    break;

                case MemberName.OuterDataAction:
                    writer.WriteEnum((int)m_outerDataAction);
                    break;

                case MemberName.GroupingType:
                    writer.WriteEnum((int)m_groupingType);
                    break;

                case MemberName.Filters:
                {
                    int value = scalabilityCache.StoreStaticReference(m_groupFilters);
                    writer.Write(value);
                    break;
                }

                case MemberName.ParentExpression:
                    writer.Write(m_parentExpression);
                    break;

                case MemberName.CurrentGroupExprValue:
                    writer.Write(m_currentGroupExprValue);
                    break;

                case MemberName.SaveGroupExprValues:
                    writer.Write(m_saveGroupExprValues);
                    break;

                case MemberName.SortFilterExpressionScopeInfoIndices:
                    writer.Write(m_sortFilterExpressionScopeInfoIndices);
                    break;

                case MemberName.BuiltinSortOverridden:
                    writer.Write(m_builtinSortOverridden);
                    break;

                case MemberName.IsDetailGroup:
                    writer.Write(m_isDetailGroup);
                    break;

                case MemberName.DetailUserSortTargetInfo:
                    writer.Write(m_detailUserSortTargetInfo);
                    break;

                case MemberName.DetailRows:
                    writer.Write(m_detailDataRows);
                    break;

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