Exemple #1
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(Sum.m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ExpressionType:
                    writer.WriteEnum((int)this.m_expressionType);
                    break;

                case MemberName.CurrentTotalType:
                    writer.WriteEnum((int)this.m_currentTotalType);
                    break;

                case MemberName.CurrentTotal:
                    writer.Write(this.m_currentTotal);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ExpressionType:
                    writer.WriteEnum((int)m_expressionType);
                    break;

                case MemberName.CurrentCount:
                    writer.Write(m_currentCount);
                    break;

                case MemberName.SumOfXType:
                    writer.WriteEnum((int)m_sumOfXType);
                    break;

                case MemberName.SumOfX:
                    writer.Write(m_sumOfX);
                    break;

                case MemberName.SumOfXSquared:
                    writer.Write(m_sumOfXSquared);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Source:
                    writer.WriteEnum((int)m_source);
                    break;

                case MemberName.Value:
                    writer.Write(m_value);
                    break;

                case MemberName.MIMEType:
                    writer.Write(m_MIMEType);
                    break;

                case MemberName.Sizing:
                    writer.WriteEnum((int)m_sizing);
                    break;

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

                case MemberName.Tag:
                {
                    ExpressionInfo persistableObj = null;
                    if (m_tags != null && m_tags.Count > 0)
                    {
                        persistableObj = m_tags[0];
                    }
                    writer.Write(persistableObj);
                    break;
                }

                case MemberName.Tags:
                    writer.Write(m_tags);
                    break;

                case MemberName.EmbeddingMode:
                    writer.WriteEnum((int)m_embeddingMode);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Exemple #4
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(Variable.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.Value:
                    writer.Write(this.m_value);
                    break;

                case MemberName.DataType:
                    writer.WriteEnum((int)this.m_constantDataType);
                    break;

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

                case MemberName.Writable:
                    writer.Write(this.m_writable);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #5
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(Filter.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Expression:
                    writer.Write(this.m_expression);
                    break;

                case MemberName.Operator:
                    writer.WriteEnum((int)this.m_operator);
                    break;

                case MemberName.Values:
                    writer.Write(this.m_values);
                    break;

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

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #6
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_declaration);
            IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;

            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ExpressionType:
                    writer.WriteEnum((int)m_expressionType);
                    break;

                case MemberName.CurrentMin:
                    writer.Write(m_currentMin);
                    break;

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(PageBreak.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.PageBreakLocation:
                    writer.WriteEnum((int)this.m_pageBreakLocation);
                    break;

                case MemberName.Disabled:
                    writer.Write(this.m_disabled);
                    break;

                case MemberName.ResetPageNumber:
                    writer.Write(this.m_resetPageNumber);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #8
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ChartMembers:
                    writer.Write(m_chartMembers);
                    break;

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

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

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(RuntimeDataRegionObj.m_declaration);
            IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;

            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.OdpContext:
                {
                    int value = scalabilityCache.StoreStaticReference(this.m_odpContext);
                    writer.Write(value);
                    break;
                }

                case MemberName.ObjectType:
                    writer.WriteEnum((int)this.m_objectType);
                    break;

                case MemberName.Depth:
                    writer.Write(this.m_depth);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #10
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ReportQuery.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.CommandType:
                    writer.WriteEnum((int)this.m_commandType);
                    break;

                case MemberName.CommandText:
                    writer.Write(this.m_commandText);
                    break;

                case MemberName.QueryParameters:
                    writer.Write(this.m_queryParameters);
                    break;

                case MemberName.Timeout:
                    writer.Write(this.m_timeOut);
                    break;

                default:
                    Global.Tracer.Assert(false, string.Empty);
                    break;
                }
            }
        }
Exemple #11
0
        void IPersistable.Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Shape:
                    writer.WriteEnum((int)m_shape);
                    break;

                case MemberName.Coordinates:
                    writer.Write(m_coordinates);
                    break;

                case MemberName.ToolTip:
                    writer.Write(m_toolTip);
                    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.ForeignKeyExpression:
                        writer.Write(m_foreignKeyExpression);
                        break;

                    case MemberName.PrimaryKeyExpression:
                        writer.Write(m_primaryKeyExpression);
                        break;

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

                    case MemberName.SortDirection:
                        writer.WriteEnum((int)m_sortDirection);
                        break;

                    default:
                        Global.Tracer.Assert(condition: false);
                        break;
                    }
                }
            }
Exemple #13
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapFieldDefinition.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

                case MemberName.DataType:
                    writer.WriteEnum((int)this.m_dataType);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        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;
                }
            }
        }
        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;
                }
            }
        }
Exemple #16
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(TextRun.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Value:
                    writer.Write(this.m_value);
                    break;

                case MemberName.ToolTip:
                    writer.Write(this.m_toolTip);
                    break;

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

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

                case MemberName.MarkupType:
                    writer.Write(this.m_markupType);
                    break;

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

                case MemberName.DataType:
                    writer.WriteEnum((int)this.m_constantDataType);
                    break;

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

                case MemberName.Paragraph:
                    writer.WriteReference(this.m_paragraph);
                    break;

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

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

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #17
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataPointValues:
                    writer.Write(m_dataPointValues);
                    break;

                case MemberName.DataLabel:
                    writer.Write(m_dataLabel);
                    break;

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

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

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

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

                case MemberName.CustomProperties:
                    writer.Write(m_customProperties);
                    break;

                case MemberName.Marker:
                    writer.Write(m_marker);
                    break;

                case MemberName.AxisLabel:
                    writer.Write(m_axisLabel);
                    break;

                case MemberName.ChartItemInLegend:
                    writer.Write(m_itemInLegend);
                    break;

                case MemberName.ToolTip:
                    writer.Write(m_toolTip);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Action:
                    writer.Write(m_action);
                    break;

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

                case MemberName.Hidden:
                    writer.Write(m_hidden);
                    break;

                case MemberName.OffsetX:
                    writer.Write(m_offsetX);
                    break;

                case MemberName.OffsetY:
                    writer.Write(m_offsetY);
                    break;

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

                case MemberName.ToolTip:
                    writer.Write(m_toolTip);
                    break;

                case MemberName.MapVectorLayer:
                    writer.WriteReference(m_mapVectorLayer);
                    break;

                case MemberName.DataElementLabel:
                    writer.Write(m_dataElementLabel);
                    break;

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

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_declaration);
            IScalabilityCache scalabilityCache = writer.PersistenceHelper as IScalabilityCache;

            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ReportObjectModel:
                {
                    int value2 = scalabilityCache.StoreStaticReference(m_reportOM);
                    writer.Write(value2);
                    break;
                }

                case MemberName.Value:
                    writer.WriteVariantOrPersistable(m_value);
                    break;

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

                case MemberName.AggregationFieldChecked:
                    writer.Write(m_aggregationFieldChecked);
                    break;

                case MemberName.FieldStatus:
                    writer.WriteEnum((int)m_fieldStatus);
                    break;

                case MemberName.Message:
                    writer.Write(m_exceptionMessage);
                    break;

                case MemberName.Properties:
                    writer.WriteStringObjectHashtable(m_properties);
                    break;

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

                case MemberName.UsedInExpression:
                    writer.Write(m_usedInExpression);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Exemple #20
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.SubReport:
                    writer.WriteGlobalReference(m_subReportDef);
                    break;

                case MemberName.Parameters:
                    if (m_parameters != null)
                    {
                        writer.Write(new ParametersImplWrapper(m_parameters));
                    }
                    else
                    {
                        writer.WriteNull();
                    }
                    break;

                case MemberName.ReportInstance:
                    writer.Write(m_reportInstance);
                    break;

                case MemberName.DataSetUniqueName:
                    writer.Write(m_instanceUniqueName);
                    break;

                case MemberName.ThreadCulture:
                    writer.Write(m_threadCulture);
                    break;

                case MemberName.Status:
                    writer.WriteEnum((int)m_status);
                    break;

                case MemberName.ProcessedWithError:
                    writer.Write(m_processedWithError);
                    break;

                case MemberName.IsInstanceShared:
                    writer.Write(m_isInstanceShared);
                    break;

                case MemberName.DataChunkNameModifier:
                    writer.Write(m_dataChunkNameModifier);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ErrorOccurred:
                    writer.Write(ErrorOccurred);
                    break;

                case MemberName.Value:
                    writer.Write(Value);
                    break;

                case MemberName.HasCode:
                    writer.Write(HasCode);
                    break;

                case MemberName.Code:
                    writer.WriteEnum((int)Code);
                    break;

                case MemberName.Severity:
                    writer.WriteEnum((int)Severity);
                    break;

                case MemberName.FieldStatus:
                    writer.WriteEnum((int)FieldStatus);
                    break;

                case MemberName.Arguments:
                    writer.Write(Arguments);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(DataAggregateObjResult.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ErrorOccurred:
                    writer.Write(this.ErrorOccurred);
                    break;

                case MemberName.Value:
                    writer.Write(this.Value);
                    break;

                case MemberName.HasCode:
                    writer.Write(this.HasCode);
                    break;

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

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

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

                case MemberName.Arguments:
                    writer.Write(this.Arguments);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.GaugePanel:
                    writer.WriteReference(m_gaugePanel);
                    break;

                case MemberName.Value:
                    writer.Write(m_value);
                    break;

                case MemberName.Formula:
                    writer.Write(m_formula);
                    break;

                case MemberName.MinPercent:
                    writer.Write(m_minPercent);
                    break;

                case MemberName.MaxPercent:
                    writer.Write(m_maxPercent);
                    break;

                case MemberName.Multiplier:
                    writer.Write(m_multiplier);
                    break;

                case MemberName.AddConstant:
                    writer.Write(m_addConstant);
                    break;

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

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

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Exemple #24
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(LookupObjResult.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.LookupTablePartitionID:
                    writer.Write(this.m_lookupTablePartitionId.Value);
                    break;

                case MemberName.HasCode:
                    writer.Write(this.m_hasErrorCode);
                    break;

                case MemberName.Code:
                    writer.WriteEnum((int)this.m_errorCode);
                    break;

                case MemberName.Severity:
                    writer.WriteEnum((int)this.m_errorSeverity);
                    break;

                case MemberName.FieldStatus:
                    writer.WriteEnum((int)this.m_dataFieldStatus);
                    break;

                case MemberName.Arguments:
                    writer.Write(this.m_errorMessageArgs);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
 public virtual void Serialize(IntermediateFormatWriter writer)
 {
     writer.RegisterDeclaration(m_declaration);
     while (writer.NextMember())
     {
         MemberName memberName = writer.CurrentMember.MemberName;
         if (memberName == MemberName.ObjectType)
         {
             writer.WriteEnum((int)m_objectType);
         }
         else
         {
             Global.Tracer.Assert(condition: false);
         }
     }
 }
Exemple #26
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(MapVectorLayer.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.MapDataRegionName:
                    writer.Write(this.m_mapDataRegionName);
                    break;

                case MemberName.MapBindingFieldPairs:
                    writer.Write(this.m_mapBindingFieldPairs);
                    break;

                case MemberName.MapFieldDefinitions:
                    writer.Write(this.m_mapFieldDefinitions);
                    break;

                case MemberName.MapSpatialData:
                    writer.Write(this.m_mapSpatialData);
                    break;

                case MemberName.ExprHostMapMemberID:
                    writer.Write(this.m_exprHostMapMemberID);
                    break;

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

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

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

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #27
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(LookupInfo.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ResultExpr:
                    writer.Write(this.m_resultExpr);
                    break;

                case MemberName.DataSetName:
                    writer.Write(this.m_dataSetName);
                    break;

                case MemberName.SourceExpr:
                    writer.Write(this.m_sourceExpr);
                    break;

                case MemberName.DestinationIndexInCollection:
                    writer.Write(this.m_destinationIndexInCollection);
                    break;

                case MemberName.Name:
                    writer.Write(this.m_name);
                    break;

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

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

                case MemberName.LookupType:
                    writer.WriteEnum((int)this.m_lookupType);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #28
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;
                }
            }
        }
Exemple #29
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(RecordSetInfo.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ReaderExtensionsSupported:
                    writer.Write(this.m_readerExtensionsSupported);
                    break;

                case MemberName.FieldPropertyNames:
                    writer.Write(this.m_fieldPropertyNames);
                    break;

                case MemberName.CompareOptions:
                    writer.WriteEnum((int)this.m_compareOptions);
                    break;

                case MemberName.FieldNames:
                    writer.Write(this.m_fieldNames);
                    break;

                case MemberName.CommandText:
                    writer.Write(this.m_commandText);
                    break;

                case MemberName.RewrittenCommandText:
                    writer.Write(this.m_rewrittenCommandText);
                    break;

                case MemberName.CultureName:
                    writer.Write(this.m_cultureName);
                    break;

                case MemberName.ExecutionTime:
                    writer.Write(this.m_executionTime);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Exemple #30
0
        public virtual void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ExpressionInfoTypeValuePair.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.DataType:
                    writer.WriteEnum((int)this.m_constantDataType);
                    break;

                case MemberName.Value:
                    writer.Write(this.m_value);
                    break;

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