public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Parameters:
                    writer.Write(m_parameters);
                    break;

                case MemberName.NoRowsMessage:
                    writer.Write(m_noRowsMessage);
                    break;

                case MemberName.MergeTransactions:
                    writer.Write(m_mergeTransactions);
                    break;

                case MemberName.ContainingScopes:
                    writer.WriteListOfReferences(m_containingScopes);
                    break;

                case MemberName.IsTablixCellScope:
                    writer.Write(m_isTablixCellScope);
                    break;

                case MemberName.ReportName:
                    writer.Write(m_reportName);
                    break;

                case MemberName.OmitBorderOnPageBreak:
                    writer.Write(m_omitBorderOnPageBreak);
                    break;

                case MemberName.KeepTogether:
                    writer.Write(m_keepTogether);
                    break;

                case MemberName.Location:
                    writer.WriteEnum((int)m_location);
                    break;

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

                case MemberName.ContainingSection:
                    writer.WriteReference(m_containingSection);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        void IPersistable.Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(ParameterDef.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Prompt:
                    writer.Write(this.m_prompt);
                    break;

                case MemberName.ValidValuesDataSource:
                    writer.Write(this.m_validValuesDataSource);
                    break;

                case MemberName.ValidValuesValueExpression:
                    writer.Write(this.m_validValuesValueExpressions);
                    break;

                case MemberName.ValidValuesLabelExpression:
                    writer.Write(this.m_validValuesLabelExpressions);
                    break;

                case MemberName.DefaultValueDataSource:
                    writer.Write(this.m_defaultDataSource);
                    break;

                case MemberName.ExpressionList:
                    writer.Write(this.m_defaultExpressions);
                    break;

                case MemberName.DependencyList:
                    writer.Write((List <ParameterDef>)null);
                    break;

                case MemberName.DependencyRefList:
                    writer.WriteListOfReferences(this.m_dependencyList);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                case MemberName.ReferenceID:
                    writer.Write(this.m_referenceId);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #3
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Page:
                    writer.Write(m_page);
                    break;

                case MemberName.ReportItems:
                    writer.Write(m_reportItems);
                    break;

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

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

                case MemberName.NeedsOverallTotalPages:
                    writer.Write(m_needsOverallTotalPages);
                    break;

                case MemberName.NeedsPageBreakTotalPages:
                    writer.Write(m_needsPageBreakTotalPages);
                    break;

                case MemberName.NeedsReportItemsOnPage:
                    writer.Write(m_needsReportItemsOnPage);
                    break;

                case MemberName.InScopeTextBoxes:
                    writer.WriteListOfReferences(m_inScopeTextBoxes);
                    break;

                case MemberName.LayoutDirection:
                    writer.Write(m_layoutDirection);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #4
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(EndUserSort.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataSet:
                    writer.WriteReference(this.m_dataSet);
                    break;

                case MemberName.SortExpressionScope:
                    writer.WriteReference(this.m_sortExpressionScope);
                    break;

                case MemberName.GroupsInSortTarget:
                    writer.WriteListOfReferences(this.m_groupsInSortTarget);
                    break;

                case MemberName.SortTarget:
                    writer.WriteReference(this.m_sortTarget);
                    break;

                case MemberName.SortExpressionIndex:
                    writer.Write(this.m_sortExpressionIndex);
                    break;

                case MemberName.DetailScopeSubReports:
                    writer.WriteListOfReferences(this.m_detailScopeSubReports);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #5
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;
                }
            }
        }
Beispiel #6
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(Page.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.PageHeader:
                    writer.Write(this.m_pageHeader);
                    break;

                case MemberName.PageFooter:
                    writer.Write(this.m_pageFooter);
                    break;

                case MemberName.PageHeight:
                    writer.Write(this.m_pageHeight);
                    break;

                case MemberName.PageHeightValue:
                    writer.Write(this.m_pageHeightValue);
                    break;

                case MemberName.PageWidth:
                    writer.Write(this.m_pageWidth);
                    break;

                case MemberName.PageWidthValue:
                    writer.Write(this.m_pageWidthValue);
                    break;

                case MemberName.LeftMargin:
                    writer.Write(this.m_leftMargin);
                    break;

                case MemberName.LeftMarginValue:
                    writer.Write(this.m_leftMarginValue);
                    break;

                case MemberName.RightMargin:
                    writer.Write(this.m_rightMargin);
                    break;

                case MemberName.RightMarginValue:
                    writer.Write(this.m_rightMarginValue);
                    break;

                case MemberName.TopMargin:
                    writer.Write(this.m_topMargin);
                    break;

                case MemberName.TopMarginValue:
                    writer.Write(this.m_topMarginValue);
                    break;

                case MemberName.BottomMargin:
                    writer.Write(this.m_bottomMargin);
                    break;

                case MemberName.BottomMarginValue:
                    writer.Write(this.m_bottomMarginValue);
                    break;

                case MemberName.InteractiveHeight:
                    writer.Write(this.m_interactiveHeight);
                    break;

                case MemberName.InteractiveHeightValue:
                    writer.Write(this.m_interactiveHeightValue);
                    break;

                case MemberName.InteractiveWidth:
                    writer.Write(this.m_interactiveWidth);
                    break;

                case MemberName.InteractiveWidthValue:
                    writer.Write(this.m_interactiveWidthValue);
                    break;

                case MemberName.Columns:
                    writer.Write(this.m_columns);
                    break;

                case MemberName.ColumnSpacing:
                    writer.Write(this.m_columnSpacing);
                    break;

                case MemberName.ColumnSpacingValue:
                    writer.Write(this.m_columnSpacingValue);
                    break;

                case MemberName.StyleClass:
                    writer.Write(this.m_styleClass);
                    break;

                case MemberName.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

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

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

                case MemberName.InScopeTextBoxes:
                    writer.WriteListOfReferences(this.m_inScopeTextBoxes);
                    break;

                case MemberName.PageAggregates:
                    writer.Write(this.m_pageAggregates);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #7
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Paragraphs:
                    writer.Write(m_paragraphs);
                    break;

                case MemberName.CanScrollVertically:
                    writer.Write(m_canScrollVertically);
                    break;

                case MemberName.CanGrow:
                    writer.Write(m_canGrow);
                    break;

                case MemberName.CanShrink:
                    writer.Write(m_canShrink);
                    break;

                case MemberName.HideDuplicates:
                    writer.Write(m_hideDuplicates);
                    break;

                case MemberName.Action:
                    writer.Write(m_action);
                    break;

                case MemberName.IsToggle:
                    writer.Write(m_isToggle);
                    break;

                case MemberName.InitialToggleState:
                    writer.Write(m_initialToggleState);
                    break;

                case MemberName.ValueReferenced:
                    writer.Write(m_valueReferenced);
                    break;

                case MemberName.TextRunValueReferenced:
                    writer.Write(m_textRunValueReferenced);
                    break;

                case MemberName.RecursiveSender:
                    writer.Write(m_recursiveSender);
                    break;

                case MemberName.DataElementStyleAttribute:
                    writer.Write(m_dataElementStyleAttribute);
                    break;

                case MemberName.ContainingScopes:
                    writer.WriteListOfReferences(m_containingScopes);
                    break;

                case MemberName.UserSort:
                    writer.Write(m_userSort);
                    break;

                case MemberName.IsTablixCellScope:
                    writer.Write(m_isTablixCellScope);
                    break;

                case MemberName.IsSubReportTopLevelScope:
                    writer.Write(m_isSubReportTopLevelScope);
                    break;

                case MemberName.RecursiveMember:
                    writer.WriteReference(m_recursiveMember);
                    break;

                case MemberName.KeepTogether:
                    writer.Write(m_keepTogether);
                    break;

                case MemberName.SequenceID:
                    writer.Write(m_sequenceID);
                    break;

                case MemberName.HasExpressionBasedValue:
                    writer.Write(m_hasExpressionBasedValue);
                    break;

                case MemberName.HasValue:
                    writer.Write(m_hasValue);
                    break;

                case MemberName.IsSimple:
                    writer.Write(m_isSimple);
                    break;

                case MemberName.HasNonRecursiveSender:
                    writer.Write(m_hasNonRecursiveSender);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        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;
                }
            }
        }
Beispiel #9
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(DataSet.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataSetCore:
                    writer.Write(this.m_dataSetCore);
                    break;

                case MemberName.DataRegions:
                    writer.WriteListOfReferences(this.m_dataRegions);
                    break;

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

                case MemberName.UsedOnlyInParameters:
                    writer.Write(this.m_usedOnlyInParameters);
                    break;

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

                case MemberName.HasDetailUserSortFilter:
                    writer.Write(this.m_hasDetailUserSortFilter);
                    break;

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

                case MemberName.HasSubReports:
                    writer.Write(this.m_hasSubReports);
                    break;

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

                case MemberName.DataSource:
                    writer.WriteReference(this.m_dataSource);
                    break;

                case MemberName.Lookups:
                    writer.Write(this.m_lookups);
                    break;

                case MemberName.LookupDestinations:
                    writer.Write(this.m_lookupDestinationInfos);
                    break;

                case MemberName.AllowIncrementalProcessing:
                    writer.Write(this.m_allowIncrementalProcessing);
                    break;

                case MemberName.DefaultRelationships:
                    writer.Write(this.m_defaultRelationships);
                    break;

                case MemberName.HasScopeWithCustomAggregates:
                    writer.Write(this.m_hasScopeWithCustomAggregates);
                    break;

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