public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.OuterGroupingCounters:
                    m_outerGroupingCounters = reader.ReadInt32Array();
                    break;

                case MemberName.OuterGroupings:
                    m_outerGroupings = reader.ReadArrayOfRIFObjects <IReference <RuntimeMemberObj> >();
                    break;

                case MemberName.InnerGroupings:
                    m_innerGroupings = reader.ReadArrayOfRIFObjects <IReference <RuntimeMemberObj> >();
                    break;

                case MemberName.InnerGroupsWithCellsForOuterPeerGroupProcessing:
                    m_innerGroupsWithCellsForOuterPeerGroupProcessing = reader.ReadListOfRIFObjects <List <IReference <RuntimeDataTablixGroupLeafObj> > >();
                    break;

                case MemberName.ScopeInstanceNumber:
                    m_scopeInstanceNumber = reader.ReadInt64();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Children:
                    m_children = reader.ReadArrayOfRIFObjects <PageItem>();
                    break;

                case MemberName.Indexes:
                    m_indexesLeftToRight = reader.ReadInt32Array();
                    break;

                case MemberName.HorizontalPadding:
                    m_rightPadding = reader.ReadDouble();
                    break;

                case MemberName.DefPadding:
                    m_definitionRightPadding = reader.ReadDouble();
                    break;

                case MemberName.VerticalPadding:
                    m_bottomPadding = reader.ReadDouble();
                    break;

                default:
                    RSTrace.RenderingTracer.Assert(condition: false, string.Empty);
                    break;
                }
            }
        }
Exemple #3
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            this.m_streamPosition = reader.ObjectStartPosition;
            reader.RegisterDeclaration(RecordRow.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.RecordFields:
                    this.m_recordFields = reader.ReadArrayOfRIFObjects <RecordField>();
                    break;

                case MemberName.IsAggregateRow:
                    this.m_isAggregateRow = reader.ReadBoolean();
                    break;

                case MemberName.AggregationFieldCount:
                    this.m_aggregationFieldCount = reader.ReadInt32();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        void IPersistable.Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.ActionDefinition:
                    base.ActionDef = (Microsoft.ReportingServices.ReportIntermediateFormat.Action)reader.ReadRIFObject();
                    break;

                case MemberName.Actions:
                    ((ROMInstanceObjectCreator)reader.PersistenceHelper).StartActionInfoInstancesDeserialization(this);
                    reader.ReadArrayOfRIFObjects <ActionInstance>();
                    ((ROMInstanceObjectCreator)reader.PersistenceHelper).CompleteActionInfoInstancesDeserialization();
                    break;

                case MemberName.ImageMapAreas:
                    m_imageMapAreas = new ImageMapAreaInstanceCollection();
                    reader.ReadListOfRIFObjects(m_imageMapAreas.InternalList);
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Exemple #5
0
        public virtual void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(DataAggregateInfo.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Name:
                    this.m_name = reader.ReadString();
                    break;

                case MemberName.AggregateType:
                    this.m_aggregateType = (AggregateTypes)reader.ReadEnum();
                    break;

                case MemberName.Expressions:
                    this.m_expressions = reader.ReadArrayOfRIFObjects <ExpressionInfo>();
                    break;

                case MemberName.DuplicateNames:
                    this.m_duplicateNames = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.DataSetIndexInCollection:
                    this.m_dataSetIndexInCollection = reader.ReadInt32();
                    break;

                case MemberName.UpdateScopeID:
                    this.m_updateScopeID = reader.ReadInt32();
                    break;

                case MemberName.UpdateScopeDepth:
                    this.m_updateScopeDepth = reader.ReadInt32();
                    break;

                case MemberName.UpdatesAtRowScope:
                    this.m_updatesAtRowScope = reader.ReadBoolean();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(CriImageInstance.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.ImageData:
                    this.m_imageData = reader.ReadByteArray();
                    break;

                case MemberName.MIMEType:
                {
                    string text = reader.ReadString();
                    if (base.ImageDef.MIMEType != null && base.ImageDef.MIMEType.IsExpression)
                    {
                        this.m_mimeTypeEvaluated = true;
                        this.m_mimeType          = text;
                    }
                    else
                    {
                        Global.Tracer.Assert(text == null, "(mimeType == null)");
                    }
                    break;
                }

                case MemberName.Actions:
                    ((ROMInstanceObjectCreator)reader.PersistenceHelper).StartActionInfoInstancesDeserialization(base.ImageDef.ActionInfo);
                    reader.ReadArrayOfRIFObjects <ActionInstance>();
                    ((ROMInstanceObjectCreator)reader.PersistenceHelper).CompleteActionInfoInstancesDeserialization();
                    break;

                case MemberName.ImageMapAreas:
                    this.m_actionInfoImageMapAreas = new ActionInfoWithDynamicImageMapCollection();
                    reader.ReadListOfRIFObjects(this.m_actionInfoImageMapAreas.InternalList);
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public virtual void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Fields:
                    m_fields = reader.ReadArrayOfRIFObjects <FieldImpl>();
                    break;

                case MemberName.Offset:
                    m_streamOffset = reader.ReadInt64();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Entries:
                    Entries = reader.ReadArrayOfRIFObjects <IScalableDictionaryEntry>();
                    break;

                case MemberName.Count:
                    Count = reader.ReadInt32();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Exemple #9
0
        public void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Parameters:
                {
                    ParameterImplWrapper[] array = reader.ReadArrayOfRIFObjects <ParameterImplWrapper>();
                    if (array == null)
                    {
                        break;
                    }
                    m_opdParameters.Collection = new ParameterImpl[array.Length];
                    for (int i = 0; i < array.Length; i++)
                    {
                        if (array[i] != null)
                        {
                            m_opdParameters.Collection[i] = array[i].WrappedParameterImpl;
                        }
                    }
                    break;
                }

                case MemberName.Names:
                    m_opdParameters.NameMap = reader.ReadStringInt32Hashtable <Hashtable>();
                    break;

                case MemberName.Count:
                    m_opdParameters.Count = reader.ReadInt32();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
 public override void Deserialize(IntermediateFormatReader reader)
 {
     base.Deserialize(reader);
     reader.RegisterDeclaration(m_declaration);
     IScalabilityCache scalabilityCache = reader.PersistenceHelper as IScalabilityCache;
     while (reader.NextMember())
     {
         switch (reader.CurrentMember.MemberName)
         {
         case MemberName.DataRegionDef:
         {
             int id2 = reader.ReadInt32();
             m_dataRegionDef = (Microsoft.ReportingServices.ReportIntermediateFormat.DataRegion)scalabilityCache.FetchStaticReference(id2);
             break;
         }
         case MemberName.OuterScope:
             m_outerScope = (IReference<IScope>)reader.ReadRIFObject();
             break;
         case MemberName.FirstRow:
             m_firstRow = (DataFieldRow)reader.ReadRIFObject();
             break;
         case MemberName.FirstRowIsAggregate:
             m_firstRowIsAggregate = reader.ReadBoolean();
             break;
         case MemberName.Filters:
         {
             int id = reader.ReadInt32();
             m_filters = (Filters)scalabilityCache.FetchStaticReference(id);
             break;
         }
         case MemberName.NonCustomAggregates:
             m_nonCustomAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
             break;
         case MemberName.CustomAggregates:
             m_customAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
             break;
         case MemberName.DataAction:
             m_dataAction = (DataActions)reader.ReadEnum();
             break;
         case MemberName.OuterDataAction:
             m_outerDataAction = (DataActions)reader.ReadEnum();
             break;
         case MemberName.RunningValues:
             m_runningValues = reader.ReadListOfPrimitives<string>();
             break;
         case MemberName.PreviousValues:
             m_previousValues = reader.ReadListOfPrimitives<string>();
             break;
         case MemberName.RunningValueValues:
             m_runningValueValues = reader.ReadArrayOfRIFObjects<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult>();
             break;
         case MemberName.RunningValueOfAggregateValues:
             m_runningValueOfAggregateValues = reader.ReadArrayOfRIFObjects<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObjResult>();
             break;
         case MemberName.PostSortAggregates:
             m_postSortAggregates = reader.ReadListOfRIFObjects<List<Microsoft.ReportingServices.ReportIntermediateFormat.DataAggregateObj>>();
             break;
         case MemberName.DataRows:
             m_dataRows = reader.ReadRIFObject<ScalableList<DataFieldRow>>();
             break;
         case MemberName.InnerDataAction:
             m_innerDataAction = (DataActions)reader.ReadEnum();
             break;
         case MemberName.UserSortTargetInfo:
             m_userSortTargetInfo = (RuntimeUserSortTargetInfo)reader.ReadRIFObject();
             break;
         case MemberName.SortFilterExpressionScopeInfoIndices:
             m_sortFilterExpressionScopeInfoIndices = reader.ReadInt32Array();
             break;
         case MemberName.InDataRowSortPhase:
             m_inDataRowSortPhase = reader.ReadBoolean();
             break;
         case MemberName.SortedDataRowTree:
             m_sortedDataRowTree = (BTree)reader.ReadRIFObject();
             break;
         case MemberName.DataRowSortExpression:
             m_dataRowSortExpression = (RuntimeExpressionInfo)reader.ReadRIFObject();
             break;
         case MemberName.AggregatesOfAggregates:
             m_aggregatesOfAggregates = (BucketedDataAggregateObjs)reader.ReadRIFObject();
             break;
         case MemberName.PostSortAggregatesOfAggregates:
             m_postSortAggregatesOfAggregates = (BucketedDataAggregateObjs)reader.ReadRIFObject();
             break;
         case MemberName.HasProcessedAggregateRow:
             m_hasProcessedAggregateRow = reader.ReadBoolean();
             break;
         default:
             Global.Tracer.Assert(condition: false);
             break;
         }
     }
 }
        void IPersistable.Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(ActionInstance.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.Label:
                {
                    string text2 = reader.ReadString();
                    if (this.m_actionDef.Label.IsExpression)
                    {
                        this.m_label = text2;
                    }
                    else
                    {
                        Global.Tracer.Assert(text2 == null, "(label == null)");
                    }
                    break;
                }

                case MemberName.BookmarkLink:
                {
                    string text4 = reader.ReadString();
                    if (this.m_actionDef.BookmarkLink != null && this.m_actionDef.BookmarkLink.IsExpression)
                    {
                        this.m_bookmark = text4;
                    }
                    else
                    {
                        Global.Tracer.Assert(text4 == null, "(bookmarkLink == null)");
                    }
                    break;
                }

                case MemberName.HyperLinkURL:
                {
                    string text = reader.ReadString();
                    if (this.m_actionDef.Hyperlink != null && this.m_actionDef.Hyperlink.IsExpression)
                    {
                        this.m_hyperlinkText = text;
                    }
                    else
                    {
                        Global.Tracer.Assert(text == null, "(hyperlink == null)");
                    }
                    break;
                }

                case MemberName.DrillthroughReportName:
                {
                    string text3 = reader.ReadString();
                    if (this.m_actionDef.Drillthrough != null && this.m_actionDef.Drillthrough.ReportName.IsExpression)
                    {
                        this.m_actionDef.Drillthrough.Instance.ReportName = text3;
                    }
                    else
                    {
                        Global.Tracer.Assert(text3 == null, "(reportName == null)");
                    }
                    break;
                }

                case MemberName.DrillthroughParameters:
                {
                    ParameterCollection paramCollection = null;
                    if (this.m_actionDef.Drillthrough != null)
                    {
                        paramCollection = this.m_actionDef.Drillthrough.Parameters;
                    }
                    ((ROMInstanceObjectCreator)reader.PersistenceHelper).StartParameterInstancesDeserialization(paramCollection);
                    reader.ReadArrayOfRIFObjects <ParameterInstance>();
                    ((ROMInstanceObjectCreator)reader.PersistenceHelper).CompleteParameterInstancesDeserialization();
                    break;
                }

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.RecordSetSize:
                    m_recordSetSize = reader.ReadInt32();
                    break;

                case MemberName.CommandText:
                    m_commandText = reader.ReadString();
                    break;

                case MemberName.RewrittenCommandText:
                    m_rewrittenCommandText = reader.ReadString();
                    break;

                case MemberName.Fields:
                    m_fieldInfos = reader.ReadArrayOfRIFObjects <FieldInfo>();
                    break;

                case MemberName.CaseSensitivity:
                    m_caseSensitivity = (DataSet.TriState)reader.ReadEnum();
                    break;

                case MemberName.AccentSensitivity:
                    m_accentSensitivity = (DataSet.TriState)reader.ReadEnum();
                    break;

                case MemberName.KanatypeSensitivity:
                    m_kanatypeSensitivity = (DataSet.TriState)reader.ReadEnum();
                    break;

                case MemberName.WidthSensitivity:
                    m_widthSensitivity = (DataSet.TriState)reader.ReadEnum();
                    break;

                case MemberName.LCID:
                    m_lcid = reader.ReadUInt32();
                    break;

                case MemberName.TablixProcessingComplete:
                    m_oldSnapshotTablixProcessingComplete = reader.ReadBoolean();
                    break;

                case MemberName.DataChunkName:
                    m_dataChunkName = reader.ReadString();
                    break;

                case MemberName.LookupResults:
                    m_lookupResults = reader.ReadListOfRIFObjects <List <LookupObjResult> >();
                    break;

                case MemberName.ExecutionTime:
                    m_executionTime = reader.ReadDateTime();
                    break;

                default:
                    Global.Tracer.Assert(condition: false);
                    break;
                }
            }
        }
Exemple #13
0
        public override void Deserialize(IntermediateFormatReader reader)
        {
            base.Deserialize(reader);
            reader.RegisterDeclaration(m_declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.InnerGroupings:
                    m_innerGroupings = reader.ReadArrayOfRIFObjects <IReference <RuntimeMemberObj> >();
                    break;

                case MemberName.CellRunningValues:
                    m_cellRVs = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.StaticCellRunningValues:
                    m_staticCellRVs = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.CellPreviousValues:
                    m_cellPreviousValues = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.StaticCellPreviousValues:
                    m_staticCellPreviousValues = reader.ReadListOfPrimitives <string>();
                    break;

                case MemberName.HeadingLevel:
                    m_headingLevel = reader.ReadInt32();
                    break;

                case MemberName.OutermostStatics:
                    m_outermostStatics = reader.ReadBoolean();
                    break;

                case MemberName.HasLeafCells:
                    m_hasLeafCells = reader.ReadBoolean();
                    break;

                case MemberName.ProcessOutermostStaticCells:
                    m_processOutermostStaticCells = reader.ReadBoolean();
                    break;

                case MemberName.CurrentMemberIndexWithinScopeLevel:
                    m_currentMemberIndexWithinScopeLevel = reader.ReadInt32();
                    break;

                case MemberName.RecursiveParentIndexes:
                    m_recursiveParentIndexes = reader.ReadListOfPrimitives <int>();
                    break;

                case MemberName.ProcessStaticCellsForRVs:
                    m_processStaticCellsForRVs = reader.ReadBoolean();
                    break;

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