示例#1
0
        public static Utf8BEncodingReader GetReader(string bencoded)
        {
            byte[] bencodedBytes = Encoding.UTF8.GetBytes(bencoded);

            var reader = new Utf8BEncodingReader(bencodedBytes);

            Assert.Equal(BEncodingTokenType.None, reader.TokenType);

            return(reader);
        }
        public static bool TryParse(ReadOnlySpan <byte> data, out ReadOnlySpan <byte> utf8value)
        {
            var reader = new Utf8BEncodingReader(data);

            if (reader.Read() &&
                reader.TokenType == BEncodingTokenType.String &&
                reader.IsEmpty)
            {
                utf8value = reader.ValueSpan;
                return(true);
            }

            utf8value = default;
            return(false);
        }
        public static bool TryParse(ReadOnlySpan <byte> data, out string value)
        {
            var reader = new Utf8BEncodingReader(data);

            if (reader.Read() &&
                reader.TokenType == BEncodingTokenType.String &&
                reader.IsEmpty &&
                reader.TryGet(out value))
            {
                return(true);
            }

            value = null;
            return(false);
        }
示例#4
0
        public static bool TryParse(ReadOnlySpan <byte> data, out BigInteger value)
        {
            var reader = new Utf8BEncodingReader(data);

            if (reader.Read() &&
                reader.TokenType == BEncodingTokenType.Integer &&
                reader.IsEmpty &&
                reader.TryGet(out value))
            {
                return(true);
            }

            value = BigInteger.Zero;
            return(false);
        }
示例#5
0
        public static bool TryParse(ReadOnlySpan <byte> data, out IBObject bObject, bool strictDictionaryOrder = true)
        {
            var             reader = new Utf8BEncodingReader(data);
            List <IBObject> stack  = null;

            bObject = null;
            BString key = null;

            while (reader.Read())
            {
                IBObject value;
                switch (reader.TokenType)
                {
                case BEncodingTokenType.String:
                    value = new BString(reader.ValueSpan);
                    break;

                case BEncodingTokenType.Integer:
                    if (!reader.TryGet(out BigInteger integer))
                    {
                        return(false);
                    }

                    value = new BInteger(integer);
                    break;

                case BEncodingTokenType.End:
                    if (stack is null || !(key is null))
                    {
                        return(false);
                    }

                    stack[stack.Count - 1].SpanEnd = reader.Consumed;

                    if (stack.Count == 1)
                    {
                        return(reader.IsEmpty);
                    }

                    Debug.Assert(stack.Count != 0);

                    stack.RemoveAt(stack.Count - 1);
                    continue;

                default:
                    Debug.Assert(reader.TokenType == BEncodingTokenType.StartDictionary || reader.TokenType == BEncodingTokenType.StartList);
                    value = reader.TokenType == BEncodingTokenType.StartDictionary
                            ? (IBObject) new BDictionary()
                            : (IBObject) new BList();

                    if (stack is null)
                    {
                        Debug.Assert(key is null);
                        stack   = new List <IBObject>(4);
                        bObject = value;
                        stack.Add(bObject);
                        continue;
                    }
                    else
                    {
                        if (stack.Count == BEncodingConstants.DepthMax)
                        {
                            return(false);
                        }
                        break;
                    }
                }

                if (stack is null)
                {
                    Debug.Assert(bObject is null && key is null);
                    Debug.Assert(reader.TokenType != BEncodingTokenType.StartDictionary);
                    Debug.Assert(reader.TokenType != BEncodingTokenType.StartList);
                    bObject = value;
                    return(reader.IsEmpty);
                }

                if (stack.Count == 0)
                {
                    return(false);
                }

                var top = stack[^ 1];