5922049812

Committed 21 Aug 2023 04:39AM UTC coverage: 20.136% (-1.6%) from 21.736%

Build # 5922049812

Build Type

push

github

Committed by

neon-sunset

Commit Message

feat: work in progress - comparers/globalization, planning, splitters and native string prototype scaffolding

Run Details

122 of 856 branches covered (14.25%)

Branch coverage included in aggregate %.

188 of 188 new or added lines in 9 files covered. (100.0%)

439 of 1930 relevant lines covered (22.75%)

26474.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Prototypes/NativeU8String.cs

using System.Text;

namespace U8Primitives; // .InteropServices?

// The best is yet to come :^)
// Q: store a bit in _length to indicate if it's null-terminated?
// Is it viable to do some tagged pointer shenanigans?
// Q: Consider some clever WeakReference handler with dealloc callback? What kind of object should I use for root?
// Q: UnmanagedU8String? How does CString look like?
// Q: NativeU8String<TAlloc>?
// Q: Always null-terminated?
// TODO: Double-check to ensure zero-extension on all casts and math (after all, _length must never be negative)
// TODO: Sanity of handling free(_ptr) seems to necessitate introducing U8Slice or U8Span after all...this is because
// _ptr must remain pointing to a start of the original allocation. Seriously consider Rust-like approach where
// 1) the main type is a string slice and 2) it can be implicitly converted to and implements the majority of the API surface,
// so worst case it is possible to just e.g. U8String[..].Split(...) or U8String.AsSpan/Slice().Split(...).
// Alternatively, this can be handled through generic extension methods but that would make it incompatible with ref structs.
// Another option: refactor abstractions into trait-like interfaces and have IUncheckedSliceable<TSelf>, ISpanConvertible<TElement>, etc.
#pragma warning disable IDE0032, RCS1085 // Use auto-implemented property. Why: readable layout
internal unsafe readonly struct NativeU8String
{
    readonly byte* _ptr;
    readonly nint _length;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public NativeU8String(byte* ptr, nint length)
    {
        _ptr = ptr;
        _length = length;
    }

    public nint Length => _length;

    // TODO: Write an analyzer that warns against indexing with `int` which can overflow.
    public ref readonly byte this[nint index]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get
        {
            if ((nuint)index >= (nuint)_length)
            {
                ThrowHelpers.IndexOutOfRange();
            }

            return ref _ptr[index];
        }
    }

    public NativeU8String this[Range range]
    {
        get
        {
            var source = this;
            var (start, length) = range.GetOffsetAndLength((int)source._length);

            if ((start > 0 && U8Info.IsContinuationByte(in source._ptr[start])) || (
                length < source.Length && U8Info.IsContinuationByte(in source._ptr[start + length])))
            {
                // TODO: Exception message UX
                ThrowHelpers.InvalidSplit();
            }

            return new(_ptr + start, length);
        }
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ReadOnlySpan<byte> AsSpan()
    {
        return new(_ptr, (int)_length);
    }

    public NativeU8String Slice(nint start)
    {
        var source = this;
        // From ReadOnly/Span<T> Slice(int) implementation
        if ((nuint)start > (nuint)source.Length)
        {
            ThrowHelpers.ArgumentOutOfRange();
        }

        var length = source.Length - start;
        if (length > 0)
        {
            if (U8Info.IsContinuationByte(in source._ptr[start]))
            {
                ThrowHelpers.InvalidSplit();
            }

            return new(source._ptr + start, length);
        }

        return default;
    }

    public NativeU8String Slice(nint start, nint length)
    {
        var source = this;
        // From ReadOnly/Span<T> Slice(int, int) implementation
        if ((nuint)start + (nuint)length > (nuint)source.Length)
        {
            ThrowHelpers.ArgumentOutOfRange();
        }

        var result = default(NativeU8String);
        if (length > 0)
        {
            // TODO: If this is always null-terminated, should we skip length check?
            if ((start > 0 && U8Info.IsContinuationByte(in source._ptr[start])) || (
                length < source.Length && U8Info.IsContinuationByte(in source._ptr[start + length])))
            {
                // TODO: Exception message UX
                ThrowHelpers.InvalidSplit();
            }

            result = new(_ptr + start, length);
        }

        return result;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static implicit operator ReadOnlySpan<byte>(NativeU8String str) => str.AsSpan();

    public override string ToString()
    {
        return Encoding.UTF8.GetString(this);
    }
}

1	using System.Text;
2
3	namespace U8Primitives; // .InteropServices?
4
5	// The best is yet to come :^)
6	// Q: store a bit in _length to indicate if it's null-terminated?
7	// Is it viable to do some tagged pointer shenanigans?
8	// Q: Consider some clever WeakReference handler with dealloc callback? What kind of object should I use for root?
9	// Q: UnmanagedU8String? How does CString look like?
10	// Q: NativeU8String<TAlloc>?
11	// Q: Always null-terminated?
12	// TODO: Double-check to ensure zero-extension on all casts and math (after all, _length must never be negative)
13	// TODO: Sanity of handling free(_ptr) seems to necessitate introducing U8Slice or U8Span after all...this is because
14	// _ptr must remain pointing to a start of the original allocation. Seriously consider Rust-like approach where
15	// 1) the main type is a string slice and 2) it can be implicitly converted to and implements the majority of the API surface,
16	// so worst case it is possible to just e.g. U8String[..].Split(...) or U8String.AsSpan/Slice().Split(...).
17	// Alternatively, this can be handled through generic extension methods but that would make it incompatible with ref structs.
18	// Another option: refactor abstractions into trait-like interfaces and have IUncheckedSliceable<TSelf>, ISpanConvertible<TElement>, etc.
19	#pragma warning disable IDE0032, RCS1085 // Use auto-implemented property. Why: readable layout
20	internal unsafe readonly struct NativeU8String
21	{
22	readonly byte* _ptr;
23	readonly nint _length;
24
25	[MethodImpl(MethodImplOptions.AggressiveInlining)]
26	public NativeU8String(byte* ptr, nint length)
27	{
28	_ptr = ptr;	×
29	_length = length;	×
30	}	×
31
32	public nint Length => _length;	×
33
34	// TODO: Write an analyzer that warns against indexing with `int` which can overflow.
35	public ref readonly byte this[nint index]
36	{
37	[MethodImpl(MethodImplOptions.AggressiveInlining)]
38	get
39	{
40	if ((nuint)index >= (nuint)_length)	×
41	{
42	ThrowHelpers.IndexOutOfRange();	×
43	}
44
45	return ref _ptr[index];	×
46	}
47	}
48
49	public NativeU8String this[Range range]
50	{
51	get
52	{
53	var source = this;	×
54	var (start, length) = range.GetOffsetAndLength((int)source._length);	×
55
56	if ((start > 0 && U8Info.IsContinuationByte(in source._ptr[start])) \|\| (	×
57	length < source.Length && U8Info.IsContinuationByte(in source._ptr[start + length])))	×
58	{
59	// TODO: Exception message UX
60	ThrowHelpers.InvalidSplit();	×
61	}
62
63	return new(_ptr + start, length);	×
64	}
65	}
66
67	[MethodImpl(MethodImplOptions.AggressiveInlining)]
68	public ReadOnlySpan<byte> AsSpan()
69	{
70	return new(_ptr, (int)_length);	×
71	}
72
73	public NativeU8String Slice(nint start)
74	{
75	var source = this;	×
76	// From ReadOnly/Span<T> Slice(int) implementation
77	if ((nuint)start > (nuint)source.Length)	×
78	{
79	ThrowHelpers.ArgumentOutOfRange();	×
80	}
81
82	var length = source.Length - start;	×
83	if (length > 0)	×
84	{
85	if (U8Info.IsContinuationByte(in source._ptr[start]))	×
86	{
87	ThrowHelpers.InvalidSplit();	×
88	}
89
90	return new(source._ptr + start, length);	×
91	}
92
93	return default;	×
94	}
95
96	public NativeU8String Slice(nint start, nint length)
97	{
98	var source = this;	×
99	// From ReadOnly/Span<T> Slice(int, int) implementation
100	if ((nuint)start + (nuint)length > (nuint)source.Length)	×
101	{
102	ThrowHelpers.ArgumentOutOfRange();	×
103	}
104
105	var result = default(NativeU8String);	×
106	if (length > 0)	×
107	{
108	// TODO: If this is always null-terminated, should we skip length check?
109	if ((start > 0 && U8Info.IsContinuationByte(in source._ptr[start])) \|\| (	×
110	length < source.Length && U8Info.IsContinuationByte(in source._ptr[start + length])))	×
111	{
112	// TODO: Exception message UX
113	ThrowHelpers.InvalidSplit();	×
114	}
115
116	result = new(_ptr + start, length);	×
117	}
118
119	return result;	×
120	}
121
122	[MethodImpl(MethodImplOptions.AggressiveInlining)]
123	public static implicit operator ReadOnlySpan<byte>(NativeU8String str) => str.AsSpan();	×
124
125	public override string ToString()
126	{
127	return Encoding.UTF8.GetString(this);	×
128	}
129	}

neon-sunset / U8String / 5922049812

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous