public bool TryGetChild(out JsonObject value)
        {
            DbRow record = _database.Get();

            if (record.SizeOrLength == 0)
            {
                value = default;
                return(false);
            }
            if (record.JsonType != JsonValueType.Object)
            {
                JsonThrowHelper.ThrowInvalidOperationException();
            }

            record = _database.Get(DbRow.Size);

            int newStart = DbRow.Size + DbRow.Size;
            int newEnd   = newStart + DbRow.Size;

            record = _database.Get(newStart);

            if (!record.IsSimpleValue)
            {
                newEnd = newEnd + DbRow.Size * record.SizeOrLength;
            }

            CustomDb copy = _database;

            copy.Span = _database.Slice(newStart, newEnd - newStart);
            value     = new JsonObject(_jsonData, copy);
            return(true);
        }
Beispiel #2
0
        public bool TryGetChild(out JsonObject value)
        {
            DbRow record = _database.Get();

            if (record.SizeOrLength == 0)
            {
                value = default;
                return(false);
            }
            if (record.JsonType != JsonType.StartObject)
            {
                JsonThrowHelper.ThrowInvalidOperationException();
            }

            record = _database.Get(DbRow.Size);

            int newStart = DbRow.Size + DbRow.Size;
            int newEnd   = newStart + DbRow.Size;

            record = _database.Get(newStart);

            if (!record.IsSimpleValue)
            {
                newEnd = newEnd + DbRow.Size * record.SizeOrLength;
            }

            value = CreateJsonObject(newStart, newEnd - newStart);
            return(true);
        }
Beispiel #3
0
        public bool TryGetChild(out JsonObject value)
        {
            DbRow record = GetRecord(0);

            if (record.Length == 0)
            {
                value = default;
                return(false);
            }
            if (record.Type != JsonValueType.Object)
            {
                JsonThrowHelper.ThrowInvalidOperationException();
            }

            record = MemoryMarshal.Read <DbRow>(_database.Slice(DbRow.Size));

            int newStart = DbRow.Size + DbRow.Size;
            int newEnd   = newStart + DbRow.Size;

            record = MemoryMarshal.Read <DbRow>(_database.Slice(newStart));

            if (!record.IsSimpleValue)
            {
                newEnd = newEnd + DbRow.Size * record.Length;
            }

            value = new JsonObject(_jsonData, _database.Slice(newStart, newEnd - newStart));
            return(true);
        }
Beispiel #4
0
        public StackRow Peek()
        {
            if (_topOfStack > _stackSpace.Length - StackRow.Size)
            {
                JsonThrowHelper.ThrowInvalidOperationException();
            }

            return(MemoryMarshal.Read <StackRow>(_stackSpace.Slice(_topOfStack)));
        }
Beispiel #5
0
 public void Dispose()
 {
     if (_pool == null)
     {
         JsonThrowHelper.ThrowInvalidOperationException("Only root object can (and should) be disposed.");
     }
     _pool.Return(_rentedBuffer);
     Span  = Span <byte> .Empty;
     Index = 0;
 }
Beispiel #6
0
        public bool TryGetValue(Utf8Span propertyName, out JsonObject value)
        {
            DbRow record = _database.Get();

            if (record.JsonType != JsonType.StartObject)
            {
                JsonThrowHelper.ThrowInvalidOperationException();
            }

            for (int i = DbRow.Size; i < _database.Length; i += DbRow.Size)
            {
                record = _database.Get(i);

                if (!record.IsSimpleValue)
                {
                    if (record.SizeOrLength != 0)
                    {
                        i += DbRow.Size * record.NumberOfRows;
                    }
                    continue;
                }

                Debug.Assert(record.JsonType == JsonType.String);

                int   startIndex = i + DbRow.Size;
                DbRow nextRecord = _database.Get(startIndex);

                if (_jsonData.Slice(record.Location, record.SizeOrLength).SequenceEqual(propertyName.Bytes))
                {
                    int length = DbRow.Size;
                    if (!nextRecord.IsSimpleValue)
                    {
                        if (nextRecord.SizeOrLength != 0)
                        {
                            length += DbRow.Size * nextRecord.NumberOfRows;
                        }
                    }

                    value = CreateJsonObject(startIndex, length);
                    return(true);
                }

                // Skip primitive value since we are looking for keys
                if (nextRecord.IsSimpleValue)
                {
                    i += DbRow.Size;
                }
            }

            value = default;
            return(false);
        }
Beispiel #7
0
        public bool TryGetValue(string propertyName, out JsonObject value)
        {
            var record = GetRecord(0);

            if (record.Length == 0)
            {
                JsonThrowHelper.ThrowKeyNotFoundException();
            }

            if (record.Type != JsonValueType.Object)
            {
                JsonThrowHelper.ThrowInvalidOperationException();
            }

            for (int i = DbRow.Size; i < _database.Length; i += DbRow.Size)
            {
                record = MemoryMarshal.Read <DbRow>(_database.Slice(i));

                if (!record.IsSimpleValue)
                {
                    i += record.Length * DbRow.Size;
                    continue;
                }

                if (new Utf8Span(_jsonData.Slice(record.Location, record.Length)) == propertyName)
                {
                    int newStart = i + DbRow.Size;
                    int newEnd   = newStart + DbRow.Size;

                    record = MemoryMarshal.Read <DbRow>(_database.Slice(newStart));

                    if (!record.IsSimpleValue)
                    {
                        newEnd = newEnd + DbRow.Size * record.Length;
                    }

                    value = new JsonObject(_jsonData, _database.Slice(newStart, newEnd - newStart));
                    return(true);
                }

                var valueType = MemoryMarshal.Read <JsonValueType>(_database.Slice(i + DbRow.Size + 8));
                if (valueType != JsonValueType.Object && valueType != JsonValueType.Array)
                {
                    i += DbRow.Size;
                }
            }

            value = default;
            return(false);
        }
Beispiel #8
0
        public bool TryGetValue(Utf8Span propertyName, out JsonObject value)
        {
            DbRow record = GetRecord(0);

            if (record.Length == 0)
            {
                JsonThrowHelper.ThrowKeyNotFoundException();
            }
            if (record.Type != JsonValueType.Object)
            {
                JsonThrowHelper.ThrowInvalidOperationException();
            }

            for (int i = DbRow.Size; i <= _database.Length; i += DbRow.Size)
            {
                record = GetRecord(i);

                if (!record.IsSimpleValue)
                {
                    i += record.Length * DbRow.Size;
                    continue;
                }

                if (_jsonData.Slice(record.Location, record.Length).SequenceEqual(propertyName.Bytes))
                {
                    int newStart = i + DbRow.Size;

                    record = GetRecord(newStart);

                    int newEnd = record.IsSimpleValue ? i + 2 * DbRow.Size : i + (record.Length + 2) * DbRow.Size;

                    value = new JsonObject(_jsonData, _database.Slice(newStart, newEnd - newStart));
                    return(true);
                }

                JsonValueType valueType = GetType(i + DbRow.Size);
                if (valueType > JsonValueType.Array)
                {
                    i += DbRow.Size;
                }
            }

            value = default;
            return(false);
        }