public override string ToString()
{
var buf = StringBuilderManager.Allocate();
lock (_arena)
{
if (_head is null)
{
StringBuilderManager.Free(buf);
return("none");
}
for (PoolChunk <T> cur = _head; ;)
{
_ = buf.Append(cur);
cur = cur.Next;
if (cur is null)
{
break;
}
_ = buf.Append(StringUtil.Newline);
}
}
return(StringBuilderManager.ReturnAndFree(buf));
}
public static string CollapseWhitespace(this string str)
{
if (str == null)
{
return(null);
}
var sb = StringBuilderManager.Allocate();
var lastChar = (char)0;
for (var i = 0; i < str.Length; i++)
{
var c = str[i];
if (c < 32)
{
continue; // Skip all these
}
if (c == 32)
{
if (lastChar == 32)
{
continue; // Only write one space character
}
}
sb.Append(c);
lastChar = c;
}
return(StringBuilderManager.ReturnAndFree(sb));
}
/// Returns the status of the allocator (which contains all metrics) as string. Be aware this may be expensive
/// and so should not called too frequently.
public string DumpStats()
{
int heapArenasLen = _heapArenas?.Length ?? 0;
var buf = StringBuilderManager.Allocate(512)
.Append(heapArenasLen)
.Append(" heap arena(s):")
.Append(StringUtil.Newline);
if (heapArenasLen > 0)
{
// ReSharper disable once PossibleNullReferenceException
foreach (PoolArena <byte[]> a in _heapArenas)
{
_ = buf.Append(a);
}
}
int directArenasLen = _directArenas?.Length ?? 0;
_ = buf.Append(directArenasLen)
.Append(" direct arena(s):")
.Append(StringUtil.Newline);
if (directArenasLen > 0)
{
// ReSharper disable once PossibleNullReferenceException
foreach (PoolArena <byte[]> a in _directArenas)
{
_ = buf.Append(a);
}
}
return(StringBuilderManager.ReturnAndFree(buf));
}
private static string AddQueryString(string uri, IEnumerable <KeyValuePair <string, string> > queryParams)
{
//if (uri is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.uri); }
//if (queryString is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.queryString); }
var anchorIndex = uri.IndexOf('#');
var uriToBeAppended = uri;
var anchorText = "";
// If there is an anchor, then the query string must be inserted before its first occurance.
if (anchorIndex != -1)
{
anchorText = uri.Substring(anchorIndex);
uriToBeAppended = uri.Substring(0, anchorIndex);
}
var queryIndex = uriToBeAppended.IndexOf('?');
var hasQuery = queryIndex != -1;
var sb = StringBuilderManager.Allocate();
_ = sb.Append(uriToBeAppended);
foreach (var parameter in queryParams)
{
_ = sb.Append(hasQuery ? '&' : '?');
_ = sb.Append(s_urlEncoder.Encode(parameter.Key));
_ = sb.Append('=');
_ = sb.Append(s_urlEncoder.Encode(parameter.Value));
hasQuery = true;
}
_ = sb.Append(anchorText);
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string CombinePaths(params string[] paths)
{
var sb = StringBuilderManager.Allocate();
AppendPaths(sb, paths);
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string HexUnescape(this string text, params char[] anyCharOf)
{
if (String.IsNullOrEmpty(text))
{
return(null);
}
if (anyCharOf == null || anyCharOf.Length == 0)
{
return(text);
}
var sb = StringBuilderManager.Allocate();
var textLength = text.Length;
for (var i = 0; i < textLength; i++)
{
var c = text.Substring(i, 1);
if (c == "%")
{
var hexNo = Convert.ToInt32(text.Substring(i + 1, 2), 16);
sb.Append((char)hexNo);
i += 2;
}
else
{
sb.Append(c);
}
}
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string HexEscape(this string text, params char[] anyCharOf)
{
if (string.IsNullOrEmpty(text))
{
return(text);
}
if (anyCharOf == null || anyCharOf.Length == 0)
{
return(text);
}
var encodeCharMap = new HashSet <char>(anyCharOf);
var sb = StringBuilderManager.Allocate();
var textLength = text.Length;
for (var i = 0; i < textLength; i++)
{
var c = text[i];
if (encodeCharMap.Contains(c))
{
sb.Append('%' + ((int)c).ToString("x"));
}
else
{
sb.Append(c);
}
}
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string UrlEncode(this string text, bool upperCase = false)
{
if (String.IsNullOrEmpty(text))
{
return(text);
}
var sb = StringBuilderManager.Allocate();
var fmt = upperCase ? "X2" : "x2";
foreach (var charCode in Encoding.UTF8.GetBytes(text))
{
if (
charCode >= 65 && charCode <= 90 || // A-Z
charCode >= 97 && charCode <= 122 || // a-z
charCode >= 48 && charCode <= 57 || // 0-9
charCode >= 44 && charCode <= 46 // ,-.
)
{
sb.Append((char)charCode);
}
else if (charCode == 32)
{
sb.Append('+');
}
else
{
sb.Append('%' + charCode.ToString(fmt));
}
}
return(StringBuilderManager.ReturnAndFree(sb));
}
internal static string BuildPath(List <JsonPosition> positions, JsonPosition?currentPosition)
{
int capacity = 0;
if (positions != null)
{
for (int i = 0; i < positions.Count; i++)
{
capacity += positions[i].CalculateLength();
}
}
if (currentPosition != null)
{
capacity += currentPosition.GetValueOrDefault().CalculateLength();
}
var sb = StringBuilderManager.Allocate(capacity);
StringWriter writer = null;
char[] buffer = null;
if (positions != null)
{
foreach (JsonPosition state in positions)
{
state.WriteTo(sb, ref writer, ref buffer);
}
}
if (currentPosition != null)
{
currentPosition.GetValueOrDefault().WriteTo(sb, ref writer, ref buffer);
}
return(StringBuilderManager.ReturnAndFree(sb));
}
static string DecodeComponent(string s, int from, int toExcluded, Encoding charset, bool isPath)
{
int len = toExcluded - from;
if (len <= 0)
{
return(StringUtil.EmptyString);
}
int firstEscaped = -1;
for (int i = from; i < toExcluded; i++)
{
char c = s[i];
if (c == HttpConstants.PercentChar || c == HttpConstants.PlusSignChar && !isPath)
{
firstEscaped = i;
break;
}
}
if (firstEscaped == -1)
{
return(s.Substring(from, len));
}
// Each encoded byte takes 3 characters (e.g. "%20")
int decodedCapacity = (toExcluded - firstEscaped) / 3;
var byteBuf = new byte[decodedCapacity];
int idx;
var strBuf = StringBuilderManager.Allocate(len);
_ = strBuf.Append(s, from, firstEscaped - from);
for (int i = firstEscaped; i < toExcluded; i++)
{
char c = s[i];
if (c != HttpConstants.PercentChar)
{
_ = strBuf.Append(c != HttpConstants.PlusSignChar || isPath ? c : StringUtil.Space);
continue;
}
idx = 0;
do
{
if (i + 3 > toExcluded)
{
StringBuilderManager.Free(strBuf); ThrowHelper.ThrowArgumentException_UnterminatedEscapeSeq(i, s);
}
byteBuf[idx++] = StringUtil.DecodeHexByte(s, i + 1);
i += 3;
}while (i < toExcluded && s[i] == HttpConstants.PercentChar);
i--;
_ = strBuf.Append(charset.GetString(byteBuf, 0, idx));
}
return(StringBuilderManager.ReturnAndFree(strBuf));
}
/// <summary>
/// Formats an event and returns the formatted message
/// </summary>
/// <param name="ctx"></param>
/// <param name="eventName">the name of the event</param>
protected virtual string Format(IChannelHandlerContext ctx, string eventName)
{
string chStr = ctx.Channel.ToString();
var sb = StringBuilderManager.Allocate(chStr.Length + 1 + eventName.Length)
.Append(chStr)
.Append(' ')
.Append(eventName);
return(StringBuilderManager.ReturnAndFree(sb));
}
public override string ToString()
{
var result = StringBuilderManager.Allocate();
foreach (IByteBuffer buf in this.value)
{
_ = result.Append(buf.ToString(this.charset));
}
return StringBuilderManager.ReturnAndFree(result);
}
public static string ToWcfJsonDateTimeOffset(DateTimeOffset dateTimeOffset)
{
var sb = StringBuilderManager.Allocate();
using (var writer = new StringWriter(sb))
{
WriteWcfJsonDateTimeOffset(writer, dateTimeOffset);
return(StringBuilderManager.ReturnAndFree(sb));
}
}
public override string ToString()
{
var buf = StringBuilderManager.Allocate().Append(base.ToString());
_ = buf.Append(StringUtil.Newline);
this.AppendHeaders(buf);
// Remove the last newline.
buf.Length = buf.Length - StringUtil.Newline.Length;
return(StringBuilderManager.ReturnAndFree(buf));
}
public static string ToMd5Hash(this byte[] bytes)
{
var hash = System.Security.Cryptography.MD5.Create().ComputeHash(bytes);
var sb = StringBuilderManager.Allocate();
foreach (byte b in hash)
{
sb.Append(b.ToString("x2"));
}
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string Join<K, V>(this Dictionary<K, V> values, string itemSeperator, string keySeperator)
{
var sb = StringBuilderManager.Allocate();
foreach (var entry in values)
{
if (sb.Length > 0)
sb.Append(itemSeperator);
sb.Append(entry.Key).Append(keySeperator).Append(entry.Value);
}
return StringBuilderManager.ReturnAndFree(sb);
}
string NewLongValue()
{
var buf = StringBuilderManager.Allocate(2 * this.data.Length + 5);
int i = 0;
i = this.AppendHexDumpField(buf, i, MachineIdLen);
i = this.AppendHexDumpField(buf, i, ProcessIdLen);
i = this.AppendHexDumpField(buf, i, SequenceLen);
i = this.AppendHexDumpField(buf, i, TimestampLen);
i = this.AppendHexDumpField(buf, i, RandomLen);
Debug.Assert(i == this.data.Length);
var strValue = buf.ToString().Substring(0, buf.Length - 1); StringBuilderManager.Free(buf); return(strValue);
}
public static string CombineWith(this string path, params object[] thesePaths)
{
if (thesePaths.Length == 1 && thesePaths[0] == null)
{
return(path);
}
var sb = StringBuilderManager.Allocate();
sb.Append(path.TrimEnd('/', '\\'));
AppendPaths(sb, ToStrings(thesePaths));
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string Join <T>(this IEnumerable <T> values, string seperator)
{
var sb = StringBuilderManager.Allocate();
foreach (var value in values)
{
if (sb.Length > 0)
{
sb.Append(seperator);
}
sb.Append(value);
}
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string DoPrettyHexDump(IByteBuffer buffer, int offset, int length)
{
if (0u >= (uint)length)
{
return(string.Empty);
}
else
{
int rows = length / 16 + (0u >= (uint)(length % 15) ? 0 : 1) + 4;
var buf = StringBuilderManager.Allocate(rows * 80);
AppendPrettyHexDump(buf, buffer, offset, length);
return(StringBuilderManager.ReturnAndFree(buf));
}
}
public void TranslateHeaders(IEnumerable <HeaderEntry <ICharSequence, ICharSequence> > inputHeaders)
{
// lazily created as needed
StringBuilder cookies = null;
foreach (var entry in inputHeaders)
{
var name = entry.Key;
var value = entry.Value;
if (_translations.TryGet(name, out var translatedName))
{
_ = _output.Add(translatedName, AsciiString.Of(value));
}
else if (!PseudoHeaderName.IsPseudoHeader(name))
{
// https://tools.ietf.org/html/rfc7540#section-8.1.2.3
// All headers that start with ':' are only valid in HTTP/2 context
if (0u >= (uint)name.Count || name[0] == ':')
{
StringBuilderManager.Free(cookies);
ThrowHelper.ThrowStreamError_InvalidHttp2HeaderEncounteredInTranslationToHttp1(_streamId, name);
}
var cookie = HttpHeaderNames.Cookie;
if (cookie.Equals(name))
{
// combine the cookie values into 1 header entry.
// https://tools.ietf.org/html/rfc7540#section-8.1.2.5
if (cookies is null)
{
cookies = StringBuilderManager.Allocate();
}
else if ((uint)cookies.Length > 0u)
{
_ = cookies.Append("; ");
}
_ = cookies.Append(value.ToString());
}
else
{
_ = _output.Add(AsciiString.Of(name), value);
}
}
}
if (cookies is object)
{
_ = _output.Add(HttpHeaderNames.Cookie, StringBuilderManager.ReturnAndFree(cookies));
}
}
private static string GetTypesKey(params Type[] types)
{
var sb = StringBuilderManager.Allocate();
foreach (var type in types)
{
if (sb.Length > 0)
{
sb.Append(">");
}
sb.Append(type.FullName);
}
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string ToXsdDuration(TimeSpan timeSpan)
{
var sb = StringBuilderManager.Allocate();
sb.Append(timeSpan.Ticks < 0 ? "-P" : "P");
double ticks = Math.Abs(timeSpan.Ticks);
double totalSeconds = ticks / TimeSpan.TicksPerSecond;
int wholeSeconds = (int)totalSeconds;
int seconds = wholeSeconds;
int sec = (seconds >= 60 ? seconds % 60 : seconds);
int min = (seconds = (seconds / 60)) >= 60 ? seconds % 60 : seconds;
int hours = (seconds = (seconds / 60)) >= 24 ? seconds % 24 : seconds;
int days = seconds / 24;
double remainingSecs = sec + (totalSeconds - wholeSeconds);
if (days > 0)
{
sb.Append(days + "D");
}
if (days == 0 || hours + min + sec + remainingSecs > 0)
{
sb.Append("T");
if (hours > 0)
{
sb.Append(hours + "H");
}
if (min > 0)
{
sb.Append(min + "M");
}
if (remainingSecs > 0)
{
var secFmt = string.Format(CultureInfo.InvariantCulture, "{0:0.0000000}", remainingSecs);
secFmt = secFmt.TrimEnd('0').TrimEnd('.');
sb.Append(secFmt + "S");
}
else if (sb.Length == 2) //PT
{
sb.Append("0S");
}
}
return(StringBuilderManager.ReturnAndFree(sb));
}
public override string ToString()
{
var freeBytes = FreeBytes;
var sb = StringBuilderManager.Allocate()
.Append("Chunk(")
.Append(RuntimeHelpers.GetHashCode(this).ToString("X"))
.Append(": ")
.Append(Usage)
.Append("%, ")
.Append(_chunkSize - freeBytes)
.Append('/')
.Append(_chunkSize)
.Append(')');
return(StringBuilderManager.ReturnAndFree(sb));
}
internal static string Underscored(IEnumerable <char> pascalCase)
{
var sb = StringBuilderManager.Allocate();
var i = 0;
foreach (var c in pascalCase)
{
if (char.IsUpper(c) && i > 0)
{
sb.Append("_");
}
sb.Append(c);
i++;
}
return(StringBuilderManager.ReturnAndFree(sb).ToLowerInvariant());
}
public override string ToString()
{
var sb = StringBuilderManager.Allocate(256);
_ = sb.Append(StringUtil.SimpleClassName(this))
.Append("(usedHeapMemory: ").Append(UsedHeapMemory)
.Append("; usedDirectMemory: ").Append(UsedDirectMemory)
.Append("; numHeapArenas: ").Append(HeapArenas().Count)
.Append("; numDirectArenas: ").Append(DirectArenas().Count)
.Append("; tinyCacheSize: ").Append(TinyCacheSize)
.Append("; smallCacheSize: ").Append(SmallCacheSize)
.Append("; normalCacheSize: ").Append(NormalCacheSize)
.Append("; numThreadLocalCaches: ").Append(NumThreadLocalCaches())
.Append("; chunkSize: ").Append(ChunkSize).Append(')');
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string AppendUrlPathsRaw(this string uri, params string[] uriComponents)
{
var sb = StringBuilderManager.Allocate();
sb.Append(uri.WithTrailingSlash());
var i = 0;
foreach (var uriComponent in uriComponents)
{
if (i++ > 0)
{
sb.Append('/');
}
sb.Append(uriComponent);
}
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string HtmlDecode(string value)
{
if (string.IsNullOrEmpty(value))
{
return(value);
}
// Don't create StringBuilder if we don't have anything to encode
if (!StringRequiresHtmlDecoding(value))
{
return(value);
}
var sb = StringBuilderManager.Allocate(value.Length);
HtmlDecodeImpl(value, sb);
return(StringBuilderManager.ReturnAndFree(sb));
}
public static string CombineWith(this string path, params string[] thesePaths)
{
if (path == null)
{
path = "";
}
if (thesePaths.Length == 1 && thesePaths[0] == null)
{
return(path);
}
var startPath = path.Length > 1 ? path.TrimEnd('/', '\\') : path;
var sb = StringBuilderManager.Allocate();
sb.Append(startPath);
AppendPaths(sb, thesePaths);
return(StringBuilderManager.ReturnAndFree(sb));
}
/// <summary>
/// Generate an HTTP/2 <c> :path</c> from a URI in accordance with
/// <a href="https://tools.ietf.org/html/rfc7230#section-5.3">rfc7230, 5.3</a>.
/// </summary>
/// <param name="uri"></param>
/// <returns></returns>
private static AsciiString ToHttp2Path(Uri uri)
{
var pathBuilder = StringBuilderManager.Allocate();
var pathAndQuery = uri.PathAndQuery;
if (!string.IsNullOrEmpty(pathAndQuery))
{
_ = pathBuilder.Append(pathAndQuery);
}
var fragment = uri.Fragment;
if (!string.IsNullOrEmpty(fragment))
{
_ = pathBuilder.Append(fragment);
}
var path = StringBuilderManager.ReturnAndFree(pathBuilder);
return(string.IsNullOrEmpty(path) ? EmptyRequestPath : new AsciiString(path));
}
