public LogicalRecordSegmentHeader ReadLogicalRecordSegmentHeader(Stream dlisStream)
        {
            if (dlisStream == null)
            {
                return(null);
            }
            if (dlisStream.BytesRemaining() < 4)
            {
                return(null);
            }

            return(new LogicalRecordSegmentHeader
            {
                LogicalRecordSegmentLength = _unormReader.ReadUNORM(dlisStream),
                LogicalRecordSegmentAttributes = _ushortReader.ReadUSHORT(dlisStream),
                LogicalRecordType = _ushortReader.ReadUSHORT(dlisStream)
            });
        }
        public VisibleRecord ReadVisibleRecord(Stream dlisStream)
        {
            if (dlisStream == null)
            {
                return(null);
            }

            var visibleRecord = new VisibleRecord
            {
                Length = _unormReader.ReadUNORM(dlisStream),
                FormatVersionField1 = _ushortReader.ReadUSHORT(dlisStream),
                FormatVersionField2 = _ushortReader.ReadUSHORT(dlisStream)
            };

            if (visibleRecord.FormatVersionField1 != 255 || visibleRecord.FormatVersionField2 != 1)
            {
                throw new Exception("invalid visible record format");
            }

            var logicalRecordSegmentData = dlisStream.ReadBytes(visibleRecord.Length - 4);

            if (logicalRecordSegmentData == null)
            {
                throw new Exception("invalid visible record length");
            }

            var logicalRecordSegments = new List <LogicalRecordSegment>();

            using (var lrsStream = new MemoryStream(logicalRecordSegmentData))
            {
                while (!lrsStream.IsAtEndOfStream())
                {
                    var lrs = _logicalRecordSegmentBusiness.ReadLogicalRecordSegment(lrsStream);
                    if (lrs == null)
                    {
                        throw new Exception("invalid logical record segment");
                    }
                    logicalRecordSegments.Add(lrs);
                }
            }
            visibleRecord.Segments = logicalRecordSegments.ToArray();

            return(visibleRecord);
        }
Exemplo n.º 3
0
 public OBNAME ReadOBNAME(Stream s)
 {
     if (s == null || s.BytesRemaining() < 3)
     {
         return(null);
     }
     return(new OBNAME
     {
         Origin = _uvariReader.ReadUVARI(s),
         CopyNumber = _ushortReader.ReadUSHORT(s),
         Identifier = _identReader.ReadIDENT(s)
     });
 }
        public LogicalRecordSegmentTrailer ReadLogicalRecordSegmentTrailer(Stream dlisStream, LogicalRecordSegmentHeader header)
        {
            if (dlisStream == null)
            {
                return(null);
            }
            if (dlisStream.IsAtBeginningOfStream())
            {
                return(null);
            }
            if (header == null)
            {
                return(null);
            }
            if (!header.HasTrailer())
            {
                return(null);
            }

            var trailer = new LogicalRecordSegmentTrailer();

            if (header.TrailingLength)
            {
                dlisStream.Seek(-2, SeekOrigin.Current);
            }
            if (header.Checksum)
            {
                dlisStream.Seek(-2, SeekOrigin.Current);
            }

            if (header.Padding)
            {
                dlisStream.Seek(-1, SeekOrigin.Current);
                trailer.PadCount = _ushortReader.ReadUSHORT(dlisStream);

                dlisStream.Seek(-trailer.PadCount, SeekOrigin.Current);
                trailer.Padding = dlisStream.ReadBytes(trailer.PadCount);
            }

            if (header.Checksum)
            {
                trailer.Checksum = _unormReader.ReadUNORM(dlisStream);
            }
            if (header.TrailingLength)
            {
                trailer.TrailingLength = _unormReader.ReadUNORM(dlisStream);
            }

            return(trailer);
        }
Exemplo n.º 5
0
        public ComponentBase ReadComponent(Stream dlisStream, AttributeComponent template = null)
        {
            if (dlisStream == null || dlisStream.IsAtEndOfStream())
            {
                return(null);
            }

            var startPosition = dlisStream.Position;

            var descriptor      = new ComponentDescriptor(_ushortReader.ReadUSHORT(dlisStream));
            var componentReader = _componentReaderFactory.GetReader(descriptor);

            if (componentReader == null)
            {
                throw new Exception($"no component reader found for role {descriptor.Role}");
            }

            var component = componentReader.ReadComponent(dlisStream, descriptor, template);

            component.StartPosition = startPosition;

            return(component);
        }