/// <summary>Appends a <see cref="char"/> to this <see cref="SpanBuilder{T}"/>.</summary>
/// <param name="value">The <see cref="char"/> to append to this <see cref="SpanBuilder{T}"/>.</param>
public void Append(char value)
{
if (_stringBuilder is not null)
{
_stringBuilder.Append(value);
}
else if (_spanBuilder._i + 1 > _spanBuilder._span.Length)
{
_stringBuilder = new(_spanBuilder._i + 1);
_stringBuilder.Append(_spanBuilder);
_stringBuilder.Append(value);
}
else
{
_spanBuilder.Append(value);
}
}
public void Span()
{
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
builder.Append("01234");
builder.Append(span.Slice(0, builder.Length));
Assert.Equal("0123401234", builder.ToString());
}
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
builder.Append("01234");
builder.Append(((ReadOnlySpan <char>)span).Slice(0, builder.Length));
Assert.Equal("0123401234", builder.ToString());
}
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
Assert.True(builder.TryAppend("01234"));
Assert.True(builder.TryAppend(span.Slice(0, builder.Length)));
Assert.Equal("0123401234", builder.ToString());
}
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
Assert.True(builder.TryAppend("01234"));
Assert.True(builder.TryAppend(((ReadOnlySpan <char>)span).Slice(0, builder.Length)));
Assert.Equal("0123401234", builder.ToString());
}
{
Span <char> span = stackalloc char[6];
var builder = new SpanBuilder(span);
builder.Append("01234");
Assert.False(builder.TryAppend(span.Slice(0, builder.Length)));
}
{
Span <char> span = stackalloc char[6];
var builder = new SpanBuilder(span);
builder.Append("01234");
Assert.False(builder.TryAppend(((ReadOnlySpan <char>)span).Slice(0, builder.Length)));
}
}
public void Primitive()
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
builder.Append((byte)1);
builder.Append((ushort)1);
builder.Append((uint)1);
builder.Append((ulong)1);
builder.Append((sbyte)1);
builder.Append((short)1);
builder.Append(1);
builder.Append((long)1);
builder.Append('1');
Assert.Equal("111111111", builder.ToString());
}
void Simplify(ref SpanBuilder builder, string source)
{
var currentCulture = CultureInfo.CurrentCulture;
var src = source.AsSpan();
var isDelimiter = false;
var srcLength = src.Length;
var lastIndex = srcLength - 1;
for (var i = 0; i < srcLength; ++i)
{
var ch = currentCulture.TextInfo.ToLower(src[i]);
if (_map.TryGetValue(ch, out var replacement))
{
builder.Append(replacement);
isDelimiter = false;
}
else
{
if (!IsSimple(ch))
{
ch = Delimiter;
}
if (Delimiter == ch)
{
if (builder.Length != 0 && i < lastIndex && !isDelimiter)
{
builder.Append(ch);
isDelimiter = true;
}
}
else
{
builder.Append(ch);
isDelimiter = false;
}
}
}
}
public void Generic()
{
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
var guid = Guid.NewGuid();
builder.Append(guid);
Assert.Equal(guid.ToString(), builder.ToString());
}
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
var guid = Guid.NewGuid();
Assert.True(builder.TryAppend(guid));
Assert.Equal(guid.ToString(), builder.ToString());
}
}
public void Double(double a, double b, string format)
{
var value = a / b;
var expected = value.ToString(format, CultureInfo.InvariantCulture);
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
builder.Append(value);
Assert.Equal(expected, builder.ToString());
}
{
Span <char> span = stackalloc char[500];
var builder = new SpanBuilder(span);
Assert.True(builder.TryAppend(value));
Assert.Equal(expected, builder.ToString());
}
{
Span <char> span = stackalloc char[expected.Length - 1];
var builder = new SpanBuilder(span);
Assert.False(builder.TryAppend(value));
}
}
public void Testing()
{
{
SpanBuilder <char> span = Span <char> .Empty;
Assert.IsTrue(span._i is 0);
Assert.IsTrue(span._span.IsEmpty);
Assert.IsTrue(span._span.Length is 0);
try
{
span.Append('a');
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
{
SpanBuilder <char> span = stackalloc char[1];
Assert.IsTrue(span._i is 0);
Assert.IsTrue(span._span.Length is 1);
span.Append('a');
Assert.IsTrue(EquateSequence <char>(span, "a"));
Assert.IsTrue(span._i is 1);
Assert.IsTrue(span._span.Length is 1);
try
{
span.Append('b');
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
{
SpanBuilder <char> span = stackalloc char[3];
Assert.IsTrue(span._i is 0);
Assert.IsTrue(span._span.Length is 3);
span.Append('a');
Assert.IsTrue(span._i is 1);
Assert.IsTrue(span._span.Length is 3);
Assert.IsTrue(EquateSequence <char>(span, "a"));
span.Append('b');
Assert.IsTrue(span._i is 2);
Assert.IsTrue(span._span.Length is 3);
Assert.IsTrue(EquateSequence <char>(span, "ab"));
span.Append('c');
Assert.IsTrue(span._i is 3);
Assert.IsTrue(span._span.Length is 3);
Assert.IsTrue(EquateSequence <char>(span, "abc"));
try
{
span.Append('d');
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
{
SpanBuilder <char> span = stackalloc char[3];
Assert.IsTrue(span._i is 0);
Assert.IsTrue(span._span.Length is 3);
span.Append("abc");
Assert.IsTrue(span._i is 3);
Assert.IsTrue(span._span.Length is 3);
Assert.IsTrue(EquateSequence <char>(span, "abc"));
try
{
span.Append('d');
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
{
SpanBuilder <char> span = stackalloc char[10];
Assert.IsTrue(span._i is 0);
Assert.IsTrue(span._span.Length is 10);
span.AppendLine('a');
Assert.IsTrue(span._i == 1 + Environment.NewLine.Length);
Assert.IsTrue(span._span.Length is 10);
Assert.IsTrue(EquateSequence <char>(span, "a" + Environment.NewLine));
span.AppendLine('b');
Assert.IsTrue(span._i == 2 + Environment.NewLine.Length * 2);
Assert.IsTrue(span._span.Length is 10);
Assert.IsTrue(EquateSequence <char>(span, "a" + Environment.NewLine + "b" + Environment.NewLine));
}
{
SpanBuilder <char> span = stackalloc char[20];
Assert.IsTrue(span._i is 0);
Assert.IsTrue(span._span.Length is 20);
span.AppendLine("ab");
Assert.IsTrue(span._i == 2 + Environment.NewLine.Length);
Assert.IsTrue(span._span.Length is 20);
Assert.IsTrue(EquateSequence <char>(span, "ab" + Environment.NewLine));
span.AppendLine("cd");
Assert.IsTrue(span._i == 4 + Environment.NewLine.Length * 2);
Assert.IsTrue(span._span.Length is 20);
Assert.IsTrue(EquateSequence <char>(span, "ab" + Environment.NewLine + "cd" + Environment.NewLine));
}
{
SpanBuilder <char> span = stackalloc char[10];
Assert.IsTrue(span._i is 0);
Assert.IsTrue(span._span.Length is 10);
span.AppendLine();
Assert.IsTrue(span._i == Environment.NewLine.Length);
Assert.IsTrue(span._span.Length is 10);
Assert.IsTrue(EquateSequence <char>(span, Environment.NewLine));
}
{
SpanBuilder <char> span = stackalloc char[1];
try
{
span.AppendLine('a');
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
{
SpanBuilder <char> span = stackalloc char[3];
try
{
span.AppendLine("abc");
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
{
SpanBuilder <char> span = stackalloc char[1];
span.Append('a');
try
{
span.AppendLine();
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
{
SpanBuilder <char> span = stackalloc char[3];
span.Append("abc");
try
{
span.AppendLine();
Assert.Fail();
}
catch (Exception exception)
{
Assert.IsTrue(exception is InvalidOperationException);
}
}
}
