コード例 #1
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(StorageItem.m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Item:
                    writer.Write(base.Item);
                    break;

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

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

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #2
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Item:
                    writer.WriteVariantOrPersistable(Item);
                    break;

                case MemberName.NextLeaf:
                    writer.Write(Next);
                    break;

                case MemberName.PrevLeaf:
                    writer.Write(Previous);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #3
0
        void IPersistable.Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ActionInfoWithDynamicImageMap.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] = ((ReportElementCollectionBase <Action>)base.Actions)[i].Instance;
                    }
                    writer.Write((IPersistable[])array);
                    break;
                }

                case MemberName.ImageMapAreas:
                    writer.WriteRIFList(this.ImageMapAreaInstances.InternalList);
                    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.GaugeScales:
                    writer.Write(m_gaugeScales);
                    break;

                case MemberName.PivotX:
                    writer.Write(m_pivotX);
                    break;

                case MemberName.PivotY:
                    writer.Write(m_pivotY);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #5
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(MapLegendTitle.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Caption:
                    writer.Write(this.m_caption);
                    break;

                case MemberName.TitleSeparator:
                    writer.Write(this.m_titleSeparator);
                    break;

                case MemberName.TitleSeparatorColor:
                    writer.Write(this.m_titleSeparatorColor);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #6
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(ChartMarker.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Type:
                    writer.Write(this.m_markerType);
                    break;

                case MemberName.Size:
                    writer.Write(this.m_markerSize);
                    break;

                case MemberName.ChartDataPoint:
                    writer.WriteReference(this.m_chartDataPoint);
                    break;

                case MemberName.ChartSeries:
                    writer.WriteReference(this.m_chartSeries);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #7
0
        public virtual 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.Source:
                    writer.Write(m_source);
                    break;

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

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

                case MemberName.TransparentColor:
                    writer.Write(m_transparentColor);
                    break;
                }
            }
        }
コード例 #8
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.IsMultiValue:
                    writer.Write(m_isMultiValue);
                    break;

                case MemberName.DestinationExpr:
                    writer.Write(m_destinationExpr);
                    break;

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

                case MemberName.UsedInSameDataSetTablixProcessing:
                    writer.Write(m_usedInSameDataSetTablixProcessing);
                    break;

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #9
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.PrintOnFirstPage:
                    writer.Write(m_printOnFirstPage);
                    break;

                case MemberName.PrintOnLastPage:
                    writer.Write(m_printOnLastPage);
                    break;

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

                case MemberName.PrintBetweenSections:
                    writer.Write(m_printBetweenSections);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #10
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.MapLineTemplate:
                    writer.Write(m_mapLineTemplate);
                    break;

                case MemberName.MapLineRules:
                    writer.Write(m_mapLineRules);
                    break;

                case MemberName.MapLines:
                    writer.Write(m_mapLines);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #11
0
 private void SetupStorage()
 {
     if (this.m_stream == null)
     {
         this.m_stream        = this.m_streamCreator.OpenStream();
         this.m_streamCreator = null;
         List <Declaration> declarations = this.m_unifiedObjectCreator.GetDeclarations();
         if (this.m_fromExistingStream)
         {
             this.m_reader = new IntermediateFormatReader(this.m_stream, this.m_unifiedObjectCreator, this.m_globalIdsFromOtherStream, this.m_scalabilityCache);
             if (this.m_stream.CanWrite)
             {
                 this.m_writer      = new IntermediateFormatWriter(this.m_stream, this.m_stream.Length, declarations, this.m_scalabilityCache, this.m_rifCompatVersion, this.m_prohibitSerializableValues);
                 this.m_writerSetup = true;
             }
             this.m_atEnd = false;
         }
         else
         {
             this.m_writer      = new IntermediateFormatWriter(this.m_stream, declarations, this.m_scalabilityCache, this.m_rifCompatVersion, this.m_prohibitSerializableValues);
             this.m_writerSetup = true;
             this.m_reader      = new IntermediateFormatReader(this.m_stream, this.m_unifiedObjectCreator, this.m_globalIdsFromOtherStream, this.m_scalabilityCache, declarations, AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.IntermediateFormatVersion.Current, PersistenceFlags.Seekable);
             this.m_atEnd       = true;
         }
         this.m_fromExistingStream = true;
     }
 }
コード例 #12
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Expression:
                    writer.Write(m_expression);
                    break;

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

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

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #13
0
        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.MapMarkerStyle:
                    writer.Write(m_mapMarkerStyle);
                    break;

                case MemberName.MapMarkerlImage:
                    writer.Write(m_mapMarkerImage);
                    break;

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #14
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(RadialScale.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.GaugePointers:
                    writer.Write(this.m_gaugePointers);
                    break;

                case MemberName.Radius:
                    writer.Write(this.m_radius);
                    break;

                case MemberName.StartAngle:
                    writer.Write(this.m_startAngle);
                    break;

                case MemberName.SweepAngle:
                    writer.Write(this.m_sweepAngle);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #15
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(MapColorRangeRule.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.StartColor:
                    writer.Write(this.m_startColor);
                    break;

                case MemberName.MiddleColor:
                    writer.Write(this.m_middleColor);
                    break;

                case MemberName.EndColor:
                    writer.Write(this.m_endColor);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #16
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(DataValue.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.ExprHostID:
                    writer.Write(this.m_exprHostID);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #17
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(Action.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.ActionItemList:
                    writer.Write(this.m_actionItemList);
                    break;

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

                case MemberName.TrackFieldsUsedInValueExpression:
                    writer.Write(this.m_trackFieldsUsedInValueExpression);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #18
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(Visibility.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Hidden:
                    writer.Write(this.m_hidden);
                    break;

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

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

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

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

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #19
0
        void IPersistable.Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ParameterInstance.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Value:
                {
                    object obj2 = null;
                    if (this.m_parameterDef.Value.IsExpression)
                    {
                        obj2 = this.Value;
                    }
                    writer.Write(obj2);
                    break;
                }

                case MemberName.Omit:
                {
                    object obj = null;
                    if (this.m_parameterDef.Omit.IsExpression && this.IsOmitAssined)
                    {
                        obj = this.Omit;
                    }
                    writer.Write(obj);
                    break;
                }

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #20
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(ChartGridLines.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Enabled:
                    writer.Write(this.m_enabled);
                    break;

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

                case MemberName.IntervalType:
                    writer.Write(this.m_intervalType);
                    break;

                case MemberName.IntervalOffset:
                    writer.Write(this.m_intervalOffset);
                    break;

                case MemberName.IntervalOffsetType:
                    writer.Write(this.m_intervalOffsetType);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #21
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(AggregateRow.m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.IsAggregateRow:
                    writer.Write(this.m_isAggregateRow);
                    break;

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

                case MemberName.ValidAggregateRow:
                    writer.Write(this.m_validAggregateRow);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #22
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;
                }
            }
        }
コード例 #23
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Position:
                    writer.Write(m_position);
                    break;

                case MemberName.InnerPlotPosition:
                    writer.Write(m_innerPlotPosition);
                    break;

                case MemberName.AxesView:
                    writer.Write(m_axesView);
                    break;

                case MemberName.Cursor:
                    writer.Write(m_cursor);
                    break;

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

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #24
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ToggleParent.m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Top:
                    writer.Write(this.m_top);
                    break;

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

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

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

                default:
                    RSTrace.ExcelRendererTracer.Assert(false);
                    break;
                }
            }
        }
コード例 #25
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(GetDeclaration());
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Color:
                    writer.Write(Color);
                    break;

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

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

                default:
                    WordOpenXmlUtils.FailSerializable();
                    break;
                }
            }
        }
コード例 #26
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;
                }
            }
        }
コード例 #27
0
        public override void Serialize(IntermediateFormatWriter writer)
        {
            base.Serialize(writer);
            writer.RegisterDeclaration(GaugeLabel.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Text:
                    writer.Write(this.m_text);
                    break;

                case MemberName.Angle:
                    writer.Write(this.m_angle);
                    break;

                case MemberName.ResizeMode:
                    writer.Write(this.m_resizeMode);
                    break;

                case MemberName.TextShadowOffset:
                    writer.Write(this.m_textShadowOffset);
                    break;

                case MemberName.UseFontPercent:
                    writer.Write(this.m_useFontPercent);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #28
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(m_declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Keys:
                    writer.WriteVariantOrPersistableArray(m_keys);
                    break;

                case MemberName.Values:
                    writer.WriteVariantOrPersistableArray(m_values);
                    break;

                case MemberName.Count:
                    writer.Write(m_count);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
コード例 #29
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(MapSize.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Map:
                    writer.WriteReference(this.m_map);
                    break;

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

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

                case MemberName.Unit:
                    writer.Write(this.m_unit);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
コード例 #30
0
        public void Serialize(IntermediateFormatWriter writer)
        {
            writer.RegisterDeclaration(ParameterImplWrapper.m_Declaration);
            while (writer.NextMember())
            {
                switch (writer.CurrentMember.MemberName)
                {
                case MemberName.Value:
                    writer.Write(this.m_odpParameter.GetValues());
                    break;

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

                case MemberName.IsMultiValue:
                    writer.Write(this.m_odpParameter.IsMultiValue);
                    break;

                case MemberName.Prompt:
                    writer.Write(this.m_odpParameter.Prompt);
                    break;

                case MemberName.IsUserSupplied:
                    writer.Write(this.m_odpParameter.IsUserSupplied);
                    break;

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