コード例 #1
0
        protected override (SegmentationStatus status, ReadOnlySequence <byte>?segment) Read(ReadOnlySequence <byte> buffer)
        {
            var startOfSegment = Starts.Select(start => buffer.PositionOf(start)).FirstOrDefault(start => start != null);

            if (startOfSegment != null)
            {
                var segment = buffer.Slice(startOfSegment.Value);

                var endOfSegment = segment.PositionOf(End);
                if (endOfSegment != null)
                {
                    var completeSegment = segment.Slice(0, segment.GetPosition(1, endOfSegment.Value));

                    if (this.Options.HasFlag(SegmentionOptions.SecondStartInvalid))
                    {
                        var secondStart = Starts.Select(start => completeSegment.PositionOf(start)).FirstOrDefault(start => start != null);
                        if (secondStart != null)
                        {
                            // Second start detected
                            return(SegmentationStatus.Invalid, buffer.Slice(0, secondStart.Value));
                        }
                    }

                    return(SegmentationStatus.Complete, completeSegment);
                }
                else if (this.MaxLength.HasValue && buffer.Length > this.MaxLength)
                {
                    var leftover = buffer.Length % this.MaxLength.Value;
                    buffer = buffer.Slice(0, buffer.GetPosition(-leftover, buffer.End));
                    return(SegmentationStatus.Invalid, buffer);
                }
            }

            return(SegmentationStatus.Incomplete, null);
        }
コード例 #2
0
        protected override (SegmentationStatus status, ReadOnlySequence <byte>?segment) Read(ReadOnlySequence <byte> buffer)
        {
            var startOfSegment = Starts.Select(start => buffer.PositionOf(start)).FirstOrDefault(start => start != null);

            if (startOfSegment != null)
            {
                var segment = buffer.Slice(startOfSegment.Value);
                if (segment.Length >= FixedLength)
                {
                    var completeSegment = segment.Slice(0, buffer.GetPosition(FixedLength, startOfSegment.Value));

                    if (this.Options.HasFlag(SegmentionOptions.SecondStartInvalid))
                    {
                        var secondStart = Starts.Select(start => completeSegment.PositionOf(start)).FirstOrDefault(start => start != null);
                        if (secondStart != null)
                        {
                            // Second start detected
                            return(SegmentationStatus.Invalid, buffer.Slice(0, secondStart.Value));
                        }
                    }

                    if (ExtensionDefinition != null)
                    {
                        var valueData = completeSegment.Slice(ExtensionDefinition.Postion, ExtensionDefinition.Length);
                        //TODO, drop the endian check... only support little and convert
                        var set = this.ExtensionDefinition.Endianness == Endianness.Little ? valueData.ToArray() : valueData.ToArray().Reverse().ToArray();

                        ulong extendedLength = 0;
                        for (var i = 0; i < this.ExtensionDefinition.Length; i++)
                        {
                            extendedLength |= (ulong)set[i] << (8 * i);
                        }

                        var actualLength = FixedLength + (long)extendedLength;

                        if (segment.Length < actualLength)
                        {
                            return(SegmentationStatus.Incomplete, buffer);
                        }

                        completeSegment = segment.Slice(0, buffer.GetPosition(actualLength, startOfSegment.Value));
                    }

                    return(SegmentationStatus.Complete, completeSegment);
                }
            }
            else if (buffer.Length > this.FixedLength)
            {
                var leftover = buffer.Length % this.FixedLength;
                buffer = buffer.Slice(0, buffer.GetPosition(-leftover, buffer.End));
                return(SegmentationStatus.Invalid, buffer);
            }

            return(SegmentationStatus.Incomplete, buffer);
        }