Beispiel #1
0
        void IPersistable.Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Value:
                {
                    object obj2 = null;
                    if (m_parameterDef.Value.IsExpression)
                    {
                        obj2 = Value;
                    }
                    writer.Write(obj2);
                    break;
                }

                case MemberName.Omit:
                {
                    object obj = null;
                    if (m_parameterDef.Omit.IsExpression && IsOmitAssined)
                    {
                        obj = Omit;
                    }
                    writer.Write(obj);
                    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.Map:
                    writer.WriteReference(m_map);
                    break;

                case MemberName.StartValue:
                    writer.Write(m_startValue);
                    break;

                case MemberName.EndValue:
                    writer.Write(m_endValue);
                    break;

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

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

                case MemberName.ColumnCount:
                    writer.Write(m_columnCount);
                    break;

                case MemberName.Navigation:
                    writer.Write(m_navigation);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #4
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(MapPolygon.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.UseCustomPolygonTemplate:
                    writer.Write(this.m_useCustomPolygonTemplate);
                    break;

                case MemberName.MapPolygonTemplate:
                    writer.Write(this.m_mapPolygonTemplate);
                    break;

                case MemberName.UseCustomPointTemplate:
                    writer.Write(this.m_useCustomCenterPointTemplate);
                    break;

                case MemberName.MapPointTemplate:
                    writer.Write(this.m_mapCenterPointTemplate);
                    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.Type:
                    writer.Write(m_type);
                    break;

                case MemberName.PointerCap:
                    writer.Write(m_pointerCap);
                    break;

                case MemberName.NeedleStyle:
                    writer.Write(m_needleStyle);
                    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.ParametersLayoutNumberOfColumns:
                    writer.Write(NumberOfColumns);
                    break;

                case MemberName.ParametersLayoutNumberOfRows:
                    writer.Write(NumberOfRows);
                    break;

                case MemberName.ParametersLayoutCellDefinitions:
                    writer.Write(CellDefinitions);
                    break;

                default:
                    Global.Tracer.Assert(condition: false, "Unexpected RIF Member for ParametersGridLayout");
                    break;
                }
            }
        }
Beispiel #7
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(Gauge.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.BackFrame:
                    writer.Write(this.m_backFrame);
                    break;

                case MemberName.ClipContent:
                    writer.Write(this.m_clipContent);
                    break;

                case MemberName.TopImage:
                    writer.Write(this.m_topImage);
                    break;

                case MemberName.AspectRatio:
                    writer.Write(this.m_aspectRatio);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(OpenXmlBorderPropertiesModel.GetDeclaration());
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Color:
                    writer.Write(this.Color);
                    break;

                case MemberName.Width:
                    writer.Write(this._widthInEighthPoints);
                    break;

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

                default:
                    WordOpenXmlUtils.FailSerializable();
                    break;
                }
            }
        }
            public void Serialize(IntermediateFormatWriter writer)
            {
                writer.RegisterDeclaration(SortHierarchyStructure.m_declaration);
                while (writer.NextMember())
                {
                    switch (writer.CurrentMember.MemberName)
                    {
                    case MemberName.SortInfo:
                        writer.Write(this.SortInfo);
                        break;

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

                    case MemberName.SortTree:
                        writer.Write(this.SortTree);
                        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.Grouping:
                    writer.Write(m_grouping);
                    break;

                case MemberName.Expression:
                    writer.Write(m_expression);
                    break;

                case MemberName.HierarchyRoot:
                    writer.Write(m_hierarchyRoot);
                    break;

                case MemberName.HierarchyObjs:
                    writer.Write(m_hierarchyObjs);
                    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.Hidden:
                    writer.Write(m_hidden);
                    break;

                case MemberName.Toggle:
                    writer.Write(m_toggle);
                    break;

                case MemberName.RecursiveReceiver:
                    writer.Write(m_recursiveReceiver);
                    break;

                case MemberName.ToggleSender:
                    writer.WriteReference(m_toggleSender);
                    break;

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

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

                case MemberName.BulbSize:
                    writer.Write(m_bulbSize);
                    break;

                case MemberName.ThermometerStyle:
                    writer.Write(m_thermometerStyle);
                    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.MapPolygonTemplate:
                    writer.Write(m_mapPolygonTemplate);
                    break;

                case MemberName.MapPolygonRules:
                    writer.Write(m_mapPolygonRules);
                    break;

                case MemberName.MapPointTemplate:
                    writer.Write(m_mapCenterPointTemplate);
                    break;

                case MemberName.MapPointRules:
                    writer.Write(m_mapCenterPointRules);
                    break;

                case MemberName.MapPolygons:
                    writer.Write(m_mapPolygons);
                    break;

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

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

                case MemberName.CurrentMax:
                    writer.Write(this.m_currentMax);
                    break;

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

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

                case MemberName.StartMargin:
                    writer.Write(this.m_startMargin);
                    break;

                case MemberName.EndMargin:
                    writer.Write(this.m_endMargin);
                    break;

                case MemberName.Position:
                    writer.Write(this.m_position);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(DataRegionInstance.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ID:
                    Global.Tracer.Assert(null != this.m_dataRegionDef, "(null != m_dataRegionDef)");
                    writer.WriteGlobalReference(this.m_dataRegionDef);
                    break;

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

                case MemberName.RowMembers:
                    writer.Write(this.m_rowMembers);
                    break;

                case MemberName.ColumnMembers:
                    writer.Write(this.m_columnMembers);
                    break;

                case MemberName.Cells2:
                    writer.Write(this.m_cells);
                    break;

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

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

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

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

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

                case MemberName.SpatialField:
                    writer.Write(this.m_spatialField);
                    break;

                case MemberName.MapFieldNames:
                    writer.Write(this.m_mapFieldNames);
                    break;

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

                case MemberName.Actions:
                {
                    ActionInstance[] array = new ActionInstance[base.Actions.Count];
                    for (int i = 0; i < array.Length; i++)
                    {
                        array[i] = base.Actions[i].Instance;
                    }
                    writer.Write(array);
                    break;
                }

                case MemberName.ImageMapAreas:
                    writer.WriteRIFList(ImageMapAreaInstances.InternalList);
                    break;

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

                case MemberName.Interval:
                    writer.Write(m_interval);
                    break;

                case MemberName.ShowLabels:
                    writer.Write(m_showLabels);
                    break;

                case MemberName.LabelPosition:
                    writer.Write(m_labelPosition);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Beispiel #21
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(PointerImage.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.HueColor:
                    writer.Write(this.m_hueColor);
                    break;

                case MemberName.Transparency:
                    writer.Write(this.m_transparency);
                    break;

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

                case MemberName.OffsetY:
                    writer.Write(this.m_offsetY);
                    break;
                }
            }
        }
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Children:
                    writer.Write(m_children);
                    break;

                case MemberName.Indexes:
                    writer.Write(m_indexesLeftToRight);
                    break;

                case MemberName.HorizontalPadding:
                    writer.Write(m_rightPadding);
                    break;

                case MemberName.DefPadding:
                    writer.Write(m_definitionRightPadding);
                    break;

                case MemberName.VerticalPadding:
                    writer.Write(m_bottomPadding);
                    break;

                default:
                    RSTrace.RenderingTracer.Assert(condition: false, string.Empty);
                    break;
                }
            }
        }
Beispiel #23
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(RecordRow.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.RecordFields:
                    writer.Write(this.m_recordFields);
                    break;

                case MemberName.IsAggregateRow:
                    writer.Write(this.m_isAggregateRow);
                    break;

                case MemberName.AggregationFieldCount:
                    writer.Write(this.m_aggregationFieldCount);
                    break;

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

                case MemberName.Source:
                    writer.Write(this.m_source);
                    break;

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

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

                case MemberName.TransparentColor:
                    writer.Write(this.m_transparentColor);
                    break;
                }
            }
        }
Beispiel #25
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapLineRules.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

                case MemberName.MapSizeRule:
                    writer.Write(this.m_mapSizeRule);
                    break;

                case MemberName.MapColorRule:
                    writer.Write(this.m_mapColorRule);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
Beispiel #26
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(HeaderFooterReferences.GetDeclaration());
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Header:
                    writer.Write(this.Header);
                    break;

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

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

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

                default:
                    WordOpenXmlUtils.FailSerializable();
                    break;
                }
            }
        }
Beispiel #27
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Top:
                    writer.Write(m_top);
                    break;

                case MemberName.Left:
                    writer.Write(m_left);
                    break;

                case MemberName.Height:
                    writer.Write(m_height);
                    break;

                case MemberName.Width:
                    writer.Write(m_width);
                    break;

                case MemberName.Chart:
                    writer.WriteReference(m_chart);
                    break;

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

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

                case MemberName.TransparentColor:
                    writer.Write(this.m_transparentColor);
                    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.Item:
                    writer.Write(Item);
                    break;

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

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

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