private bool TryAddComponent(ValueString item, ref ValueString all, ref int nextStart)
{
if (item._length == 0)
{
return(true);
}
if (all._string == null)
{
nextStart = item._start;
all._start = item._start;
all._string = item._string;
}
else
{
if (!object.ReferenceEquals(item._string, all._string))
{
return(false);
}
if (item._start != nextStart)
{
return(false);
}
}
all._length += item._length;
nextStart += item._length;
return(true);
}
public unsafe void EnsureSpace(int length)
{
if (used + length > str.Length)
{
int newSize;
checked
{
var minimumNewSize = length + used;
do
{
newSize = used * 2;
}while (newSize < minimumNewSize);
}
var newStr = ValueString.AllocateString(newSize);
fixed(char *dest = newStr)
fixed(char *source = str)
{
Buffer.MemoryCopy((void *)source, dest, newStr.Length * 2, used * 2);
}
str = newStr;
}
}
public void EnsureSpace(int length)
{
if (used + length > str.Length)
{
str = ValueString.AllocateString(Math.Max(length, blockSize));
used = 0;
}
}
public unsafe ValueString Concatenate(ValueString vs1, ValueString vs2)
{
EnsureSpace(vs1.Length + vs2.Length);
var m = used;
CreateValueString(vs1);
CreateValueString(vs2);
return(new ValueString(str, m, vs1._length + vs2._length));
}
public static void Release(StringBuilder sb)
{
var u = _unusedStringBuilders;
if (u != null && u.Count < 4 && ValueString.ShouldKeepReleasedStringBuilder(sb))
{
sb.Length = 0;
u.Add(sb);
}
}
public static string SubstringCached(this ValueString str, int startIndex, int length)
{
var reader = valueStringReader ?? (valueStringReader = new ValueStringReader());
reader.ValueString = str;
var result = reader.SubstringCached(startIndex, length);
reader.ValueString._string = null;
return(result);
}
public static void WriteValueString(this TextWriter writer, ValueString str)
{
var start = str._start;
var end = start + str._length;
var text = str._string;
for (int i = start; i < end; i++)
{
writer.Write(text[i]);
}
}
public unsafe ValueString Concatenate(ValueString vs1, ValueString vs2)
{
if (object.ReferenceEquals(vs1._string, vs2._string) && vs1._start + vs1._length == vs2._start)
{
return(new ValueString(vs1._string, vs1._start, vs1._length + vs2._length));
}
EnsureSpace(vs1.Length + vs2.Length);
var m = used;
CreateValueString(vs1);
CreateValueString(vs2);
return(new ValueString(str, m, vs1._length + vs2._length));
}
private bool IsAllFromSameString(List <ValueString> strings, out ValueString all)
{
all = default(ValueString);
int nextStart = -1;
foreach (var item in strings)
{
if (!TryAddComponent(item, ref all, ref nextStart))
{
return(false);
}
}
return(true);
}
public unsafe ValueString CreateValueString(ValueString vs)
{
EnsureSpace(vs._length);
fixed(char *dest = str)
{
var destx = dest + used;
var offset = used;
fixed(char *source = vs._string)
{
#if NET35
ValueString.CopyChars(source + vs._start, destx, vs._length);
#else
Buffer.MemoryCopy((void *)(source + vs._start), destx, vs._length * 2, vs._length * 2);
#endif
}
used += vs._length;
return(new ValueString(str, offset, vs._length));
}
}
public unsafe ValueString CreateValueString(char[] arr, int start, int length)
{
if (length == 0)
{
return(ValueString.Empty);
}
if (start + length > arr.Length)
{
throw new ArgumentException();
}
EnsureSpace(length);
fixed(char *ptr = str)
{
fixed(char *src = arr)
{
ValueString.CopyChars(ptr + used, src + start, length);
var offset = used;
used += length;
return(new ValueString(str, offset, length));
}
}
}
public static StringBuilder AppendValueString(this StringBuilder sb, ValueString str, int start, int count)
{
return(sb.Append(str._string, str._start + start, count));
}
public static StringBuilder AppendValueString(this StringBuilder sb, ValueString str)
{
return(sb.AppendValueString(str._string, str._start, str._length));
}
public void AppendValueString(ValueString str)
{
ValueStringExtensions.AppendValueString(_sb, str);
}
public static string SubstringCached(this ValueString str, int startIndex)
{
return(str.SubstringCached(startIndex, str.Length - startIndex));
}
public MultiValueStringBuilder(int blockSize)
{
this.blockSize = blockSize;
this.str = ValueString.AllocateString(blockSize);
}
public static void WriteValueStringLine(this TextWriter writer, ValueString str)
{
writer.WriteValueString(str);
writer.WriteLine();
}
public static string SubstringCached(this ValueString str)
{
return(str.SubstringCached(0, str.Length));
}
