Beispiel #1
0
        public bool TryGet(ref Position position, out Span <T> item, bool advance = false)
        {
            item = default(Span <T>);

            if (_count == 0)
            {
                position = Position.AfterLast;
                return(false);
            }

            if (position.Equals(Position.BeforeFirst))
            {
                if (advance)
                {
                    position = Position.First;
                }
                return(false);
            }

            if (position.Equals(Position.AfterLast))
            {
                return(false);
            }

            item = this[position.IntegerPosition];
            if (advance)
            {
                position.IntegerPosition++;
                if (position.IntegerPosition >= _count)
                {
                    position = Position.AfterLast;
                }
            }
            return(true);
        }
Beispiel #2
0
        public static bool TryParseUInt32 <TSequence>(this TSequence bytes, EncodingData encoding, out uint value, out int consumed) where TSequence : ISpanSequence <byte>
        {
            Position    position = Position.First;
            Span <byte> first;

            if (!bytes.TryGet(ref position, out first, advance: true))
            {
                throw new ArgumentException("bytes cannot be empty");
            }

            if (!PrimitiveParser.TryParseUInt32(first, EncodingData.Encoding.Utf8, out value, out consumed))
            {
                return(false); // TODO: maybe we should continue in some cases, e.g. if the first span ends in a decimal separator
                               // ... cont, maybe consumed could be set even if TryParse returns false
            }
            if (position.Equals(Position.AfterLast) || first.Length > consumed)
            {
                return(true);
            }

            Span <byte> second;

            if (!bytes.TryGet(ref position, out second, advance: true))
            {
                throw new ArgumentException("bytes cannot be empty");
            }

            Span <byte> temp;
            int         numberOfBytesFromSecond = second.Length;

            if (numberOfBytesFromSecond > 64)
            {
                numberOfBytesFromSecond = 64;
            }
            var tempBufferLength = first.Length + numberOfBytesFromSecond;

            if (tempBufferLength > 128)
            {
                temp = new byte[tempBufferLength];
            }
            else
            {
                unsafe
                {
                    byte *data = stackalloc byte[tempBufferLength];
                    temp = new Span <byte>(data, tempBufferLength);
                }
            }

            first.CopyTo(temp);

            second.Slice(0, numberOfBytesFromSecond).CopyTo(temp.Slice(first.Length));

            if (!PrimitiveParser.TryParseUInt32(temp, EncodingData.Encoding.Utf8, out value, out consumed))
            {
                return(false);
            }

            if (position.Equals(Position.AfterLast) || temp.Length > consumed)
            {
                return(true);
            }

            throw new NotImplementedException();
        }