/// <summary>
/// Creates a list that stores information for the events.
/// </summary>
/// <returns></returns>
private List <EventInfoWithComment> CreateEventList()
{
List <EventInfoWithComment> list = new List <EventInfoWithComment>();
Dictionary <string?, XmlComment> comments = new Dictionary <string?, XmlComment>();
if (m_CommentLookup != null)
{
foreach (var comment in m_CommentLookup[Info.FormatToXmlCommentTypeName()].Where(x => x.Kind == XmlCommentKind.Event))
{
comments.Add(comment.MemberName, comment);
}
}
foreach (var evt in Info.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static))
{
if (Context.EventFilter != null && !Context.EventFilter(evt))
{
continue;
}
var name = ZString.CreateStringBuilder();
name.Append(evt.Name);
comments.TryGetValue(name.ToString(), out var comment);
list.Add(new EventInfoWithComment(evt, comment, Context));
}
list.Sort((a, b) => a.Info.Name.CompareTo(b.Info.Name));
return(list);
}
/// <summary>
/// Removes unsupported characters or other sets of sequences we don't want parsed.
/// </summary>
/// <param name="sb"></param>
public static void RemoveUnsupportedCharacters(this StringBuilder sb)
{
// It was almost 3 times faster to use a value based string builder and then
// repopulate the original StringBuilder with the processed output.
using (var zsb = ZString.CreateStringBuilder())
{
foreach (ReadOnlyMemory <char> chunk in sb.GetChunks())
{
foreach (char ch in chunk.Span)
{
if (!_unsupportedChars.Contains(ch))
{
zsb.Append(ch);
}
}
}
// Remove the up, down, left, right, blink, reverse and underline. We're not supporting
// these at this time although we will support come of them in the future.
if (zsb.AsSpan().IndexOf('\x1B') != -1)
{
zsb.Replace(UP, "");
zsb.Replace(DOWN, "");
zsb.Replace(RIGHT, "");
zsb.Replace(LEFT, "");
zsb.Replace(BLINK, "");
zsb.Replace(CLEAR_SCREEN, "");
}
sb.Clear();
sb.Append(zsb.AsSpan());
}
}
/// <summary>
/// Format it to a human-readable name or signature, like "Item[int]".
/// </summary>
/// <param name="property"></param>
/// <returns></returns>
public static string FormatToReadableSignature(this PropertyInfo property)
{
var parameters = property.GetIndexParameters();
if (parameters == null || parameters.Length == 0)
{
return(property.Name);
}
var sb = ZString.CreateStringBuilder();
sb.Append(property.Name);
sb.Append("[");
for (int i = 0; i < parameters.Length; ++i)
{
if (i > 0)
{
sb.Append(", ");
}
sb.Append(parameters[i].ParameterType.FormatToReadableTypeName(false));
}
sb.Append("]");
return(sb.ToString());
}
/// <summary>
/// Loads and pre-processes a shader source file.
/// </summary>
/// <param name="assetManager">The AssetManager to be used to resolve the asset paths.</param>
/// <param name="shaderPath">The path of the shader source file.</param>
/// <param name="shaderIncludePaths">The resulting list of included file paths referenced by the shader.</param>
public static string Process(AssetManager assetManager,
string shaderPath,
out List <string> shaderIncludePaths)
{
// Uses ZString as a StringBuilder alternative to reduce heap allocations.
// Uses ReadOnlyMemory<char> instead of string where possible for slightly better performance.
// TODO: This needs more testing with larger asset libraries down the road.
// System.Text.StringBuilder is slightly faster in my testing, but uses a lot more heap allocations.
// If the time difference is non-negligible for larger asset files, it may be beneficial to switch back to
// System.Text.StringBuilder since shaders are only pre-processed when they're loaded, so the heap
// allocations aren't really an issue.
Utf16ValueStringBuilder stringBuilder = ZString.CreateStringBuilder();
shaderIncludePaths = new List <string>();
PreprocessShaderSource(assetManager,
ref stringBuilder,
shaderPath,
shaderIncludePaths = new List <string>(),
new Stack <string>());
string result = stringBuilder.ToString();
return(result);
}
/// <summary>
/// Converts the specified string to anchor format.
/// </summary>
/// <param name="text">The text.</param>
/// <returns>The formatted anchor.</returns>
public static string?ToAnchor(string?text)
{
if (text == null || text == "")
{
return(text);
}
var sb = ZString.CreateStringBuilder();
foreach (var c in text.ToLower())
{
if (Array.IndexOf(s_AnchorIgnoreChars, c) >= 0)
{
continue;
}
if (c == ' ')
{
continue;
}
if (c == ' ')
{
sb.Append('-');
}
else
{
sb.Append(c);
}
}
return(sb.ToString());
}
/// <summary>
/// Outputs the specified string in a bullet list.
/// </summary>
/// <returns></returns>
public static string WriteBullets(IEnumerable <string> lines, string mark = "*", int indent = 0)
{
if (lines == null)
{
return("");
}
var sb = ZString.CreateStringBuilder();
foreach (var line in lines)
{
if (line == null || line == "")
{
continue;
}
for (int i = 0; i < indent; ++i)
{
sb.Append(" ");
}
if (!string.IsNullOrEmpty(mark))
{
sb.Append(mark);
sb.Append(" ");
}
sb.Append(line);
sb.Append(Environment.NewLine);
}
return(sb.ToString());
}
public void Write(ref LogMessage message)
{
if (_level == LOG_LEVEL_DISABLED || _level > message.Level)
{
return;
}
using (var sb = ZString.CreateStringBuilder(true))
{
if ((_flags & APPENDER_FLAGS_PREFIX_TIMESTAMP) != 0)
{
sb.Append(message.getTimeStr());
sb.Append(" ");
}
if ((_flags & APPENDER_FLAGS_PREFIX_LOGLEVEL) != 0)
{
sb.AppendFormat("{0,-5} ", GetLogLevelString(message.Level));
}
if ((_flags & APPENDER_FLAGS_PREFIX_LOGFILTERTYPE) != 0)
{
sb.Append("[");
sb.Append(message.Type);
sb.Append("] ");
}
message.Prefix = sb.ToString();
_Write(ref message);
}
}
/// <summary>
/// Returns a file friendly format of this name in YYYY-MM-DD format. If the includeTime parameter is true then the format
/// will be YYYY-MM-DD-HH.MM.SS.MS
/// </summary>
/// <param name="d"></param>
/// <param name="includeTime"></param>
public static string ToFileNameFriendlyFormat(this DateTime d, bool includeTime = false)
{
using (var sb = ZString.CreateStringBuilder())
{
sb.Append(d.Year);
sb.Append('-');
if (d.Month < 10)
{
sb.Append('0');
}
sb.Append(d.Month);
sb.Append('-');
if (d.Day < 10)
{
sb.Append('0');
}
sb.Append(d.Day);
if (!includeTime)
{
return(sb.ToString());
}
sb.AppendFormat("-{0}.{1}.{2}.{3}", d.Hour, d.Minute, d.Second, d.Millisecond);
return(sb.ToString());
}
}
public void outCharDump(string?str, uint accountId, ulong guid, string name)
{
if (string.IsNullOrEmpty(str) || !ShouldLog("entities.player.dump", LOG_LEVEL_INFO))
{
return;
}
using (var sb = ZString.CreateStringBuilder(true))
{
sb.Append("== START DUMP == (account: ");
sb.Append(accountId);
sb.Append(" guid: ");
sb.Append(guid);
sb.Append(" name: ");
sb.Append(name);
sb.Append(")");
sb.AppendLine();
sb.Append(str);
sb.AppendLine();
sb.Append("== END DUMP ==");
sb.AppendLine();
var msg = new LogMessage(LOG_LEVEL_INFO, "entities.player.dump", sb.ToString());
sb.Clear();
sb.Append(guid);
sb.Append('_');
sb.Append(name);
msg.Param1 = sb.ToString();
Write(ref msg);
}
}
public void InsertStringTest()
{
string initialValue = "--[]--";
using (var zsb = ZString.CreateStringBuilder(notNested: true))
{
string xyz = "xyz";
zsb.Append(initialValue);
var bcl = new StringBuilder(initialValue);
zsb.Insert(3, xyz, 2);
bcl.Insert(3, xyz, 2);
zsb.ToString().Should().Be(bcl.ToString());
zsb.Insert(3, xyz);
bcl.Insert(3, xyz);
zsb.ToString().Should().Be(bcl.ToString());
zsb.Insert(0, "<<");
bcl.Insert(0, "<<");
zsb.ToString().Should().Be(bcl.ToString());
var endIndex = zsb.Length - 1;
zsb.Insert(endIndex, ">>");
bcl.Insert(endIndex, ">>");
zsb.ToString().Should().Be(bcl.ToString());
}
}
private Token ReadComment(int fromLine, int fromCol)
{
using (var sb = ZString.CreateStringBuilder())
{
bool extraneousFound = false;
for (char c = this.CursorCharNext(); this.CursorNotEof(); c = this.CursorCharNext())
{
if (c == '[' && !extraneousFound && sb.Length > 0)
{
sb.Append('[');
string comment = this.ReadLongString(fromLine, fromCol, sb.ToString(), "comment");
return(this.CreateToken(TokenType.Comment, fromLine, fromCol, comment));
}
if (c == '\n')
{
this.CursorCharNext();
return(this.CreateToken(TokenType.Comment, fromLine, fromCol, sb.ToString()));
}
if (c != '\r')
{
if (c != '[' && c != '=')
{
extraneousFound = true;
}
sb.Append(c);
}
}
return(this.CreateToken(TokenType.Comment, fromLine, fromCol, sb.ToString()));
}
}
private static string BuildServerTimingHeader(IReadOnlyList <IMetric> metrics, bool includeDescription)
{
using var builder = ZString.CreateStringBuilder(true);
for (var i = 0; i < metrics.Count; i++)
{
var metric = metrics[i];
builder.Append(metric.Name);
if (metric.Duration.HasValue)
{
builder.AppendFormat(";dur={0}", metric.Duration.Value);
}
if (includeDescription && !string.IsNullOrWhiteSpace(metric.Description))
{
builder.AppendFormat(";desc=\"{0}\"", metric.Description);
}
if (i != metrics.Count - 1)
{
builder.Append(",");
}
}
return(builder.ToString());
}
/// <summary>
/// Gets the expression used in the declaration.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string GetDeclaration(this GenericParameterAttributes value)
{
var sb = ZString.CreateStringBuilder();
if ((value & GenericParameterAttributes.ReferenceTypeConstraint) > 0)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append("class");
}
if ((value & GenericParameterAttributes.NotNullableValueTypeConstraint) > 0)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append("struct");
}
if ((value & GenericParameterAttributes.DefaultConstructorConstraint) > 0 && ((value & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0))
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append("new()");
}
return(sb.ToString());
}
public int ZReplaceString()
{
using var zsb = ZString.CreateStringBuilder(true);
zsb.Append(text);
zsb.Replace(" ", "\r\n");
return(zsb.Length); // Use Length to avoid omitting it
}
public int ZNotReplaced()
{
using var zsb = ZString.CreateStringBuilder(true);
zsb.Append(text);
zsb.Replace(guid, "XXXXXX"); // GUID value should not be included in this file.
return(zsb.Length); // Use Length to avoid omitting it
}
public static DynValue @char(ScriptExecutionContext executionContext, CallbackArguments args)
{
using (var sb = ZString.CreateStringBuilder())
{
for (int i = 0; i < args.Count; i++)
{
var v = args[i];
double d = 0d;
if (v.Type == DataType.String)
{
var nd = v.CastToNumber();
if (nd == null)
{
args.AsType(i, "char", DataType.Number);
}
else
{
d = nd.Value;
}
}
else
{
args.AsType(i, "char", DataType.Number);
d = v.Number;
}
sb.Append((char)(d));
}
return(DynValue.NewString(sb.ToString()));
}
}
/// <summary>
/// Gets the description.
/// </summary>
/// <param name="delimiter">The delimiter when multiple descriptions are listed.</param>
/// <returns>The description.</returns>
public string GetDescription(string delimiter = " ")
{
if (Descriptions == null)
{
return("");
}
if (Descriptions.Count == 0)
{
return("");
}
if (Descriptions.Count == 1)
{
return(Descriptions[0] ?? "");
}
var sb = ZString.CreateStringBuilder();
for (int i = 0; i < Descriptions.Count; ++i)
{
if (i > 0 && sb.Length > 0)
{
sb.Append(delimiter);
}
sb.Append(Descriptions[i]);
}
return(sb.ToString());
}
public int Utf16StringBuilderAppendFormat_()
{
using var zsh = ZString.CreateStringBuilder();
zsh.AppendFormat(_format,
_byte, _dt, _dto, _decimal, _double, _guid, _short, _float, _ts, _uint, _ulong, _null, _string, _bool, _enum, _char);
return(zsh.Length);
}
/// <summary>
/// Custom version of <see cref="QueryHelpers.AddQueryString(String,String,String)"/> that takes our pre-built
/// dictionary, uri as ReadOnlySpan<char> and uses ZString. Otherwise same logic.
/// </summary>
private static string AddQueryString(
ReadOnlySpan <char> uri,
Dictionary <string, StringValues> queryString)
{
var anchorIndex = uri.IndexOf('#');
var uriToBeAppended = uri;
var anchorText = ReadOnlySpan <char> .Empty;
// If there is an anchor, then the query string must be inserted before its first occurrence.
if (anchorIndex != -1)
{
anchorText = uri.Slice(anchorIndex);
uriToBeAppended = uri.Slice(0, anchorIndex);
}
var queryIndex = uriToBeAppended.IndexOf('?');
var hasQuery = queryIndex != -1;
using var sb = ZString.CreateStringBuilder();
sb.Append(uriToBeAppended);
foreach (var parameter in queryString)
{
sb.Append(hasQuery ? '&' : '?');
sb.Append(UrlEncoder.Default.Encode(parameter.Key));
sb.Append('=');
sb.Append(UrlEncoder.Default.Encode(parameter.Value));
hasQuery = true;
}
sb.Append(anchorText);
return(sb.ToString());
}
public override string FormatSelectSql(string tableName, ref MemoryBuffer <DbHint> hints)
{
var sb = ZString.CreateStringBuilder();
try {
sb.Append("SELECT * FROM ");
FormatTableNameTo(ref sb, tableName);
var isFirst = true;
foreach (var hint in hints)
{
if (isFirst)
{
sb.Append(" FOR ");
}
else
{
sb.Append(' ');
}
sb.Append(FormatHint(hint));
isFirst = false;
}
return(sb.ToString());
}
finally {
sb.Dispose();
}
}
public void Others()
{
using (var sb1 = ZString.CreateStringBuilder())
//using (var sb2 = ZString.CreateUtf8StringBuilder())
using (var sb3 = ZString.CreateStringBuilder())
//using (var sb4 = ZString.CreateUtf8StringBuilder())
{
var x = DateTime.Now;
var y = DateTimeOffset.Now;
var z = TimeSpan.FromMilliseconds(12345.6789);
var g = Guid.NewGuid();
var sb5 = new StringBuilder();
sb1.Append(x); sb1.Append(y); sb1.Append(z); sb1.Append(g);
//sb2.Append(x, StandardFormat.Parse("O")); sb2.Append(y, StandardFormat.Parse("O")); sb2.Append(z); sb2.Append(g);
sb3.Append(x); sb3.Append(y); sb3.Append(z); sb3.Append(g);
//sb4.Concat(x, y, z, g);
sb5.Append(x); sb5.Append(y); sb5.Append(z); sb5.Append(g);
//sb1.ToString().Should().Be(sb2.ToString());
sb1.ToString().Should().Be(sb3.ToString());
//sb1.ToString().Should().Be(sb4.ToString());
sb1.ToString().Should().Be(sb5.ToString());
}
}
void CleanUp(AppliedFileStorage storage)
{
if (storage.Count == 0)
{
return;
}
using (var update = ZString.CreateStringBuilder(true))
{
var remaining = storage.Count;
update.Append("DELETE FROM `updates` WHERE `name` IN(");
foreach (var item in storage)
{
update.Append("\"");
update.Append(item.Key);
update.Append("\"");
if ((--remaining) > 0)
{
update.Append(", ");
}
}
update.Append(")");
// Update database
_apply(update.ToString());
}
}
public ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, LiquidTemplateContext ctx)
{
var inputObj = input.ToObjectValue();
var whitelist = arguments.At(0)?.ToStringValue()?.Split(',');
if (inputObj is Arguments shortcodeArgs && whitelist?.Length > 0)
{
using var sb = ZString.CreateStringBuilder();
sb.Append(" ");
foreach (var arg in shortcodeArgs)
{
// todo: remove this when OC supports - in shortcode arguments
// temporary code to support arguments that contain a - since OC currently does not support
var key = arg.Key.Replace('_', '-');
if (whitelist.Contains(key))
{
sb.Append($"{key}=\"{arg.Value}\" ");
}
else if (whitelist.Contains(arg.Value))
{
// for boolean arguments that are valid for vue.js
sb.Append($"{arg.Value} ");
}
}
return(new StringValue(sb.ToString()));
}
return(StringValue.Empty);
}
public static DynValue rep(ScriptExecutionContext executionContext, CallbackArguments args)
{
var arg_s = args.AsType(0, "rep", DataType.String);
var arg_n = args.AsType(1, "rep", DataType.Number);
var arg_sep = args.AsType(2, "rep", DataType.String, true);
if (string.IsNullOrEmpty(arg_s.String) || (arg_n.Number < 1))
{
return(DynValue.NewString(""));
}
string sep = (arg_sep.IsNotNil()) ? arg_sep.String : null;
int count = (int)arg_n.Number;
using (var sb = ZString.CreateStringBuilder())
{
for (int i = 0; i < count; ++i)
{
if (i != 0 && sep != null)
{
sb.Append(sep);
}
sb.Append(arg_s.String);
}
return(DynValue.NewString(sb.ToString()));
}
}
public void Utf16DisposeTest()
{
var sb = ZString.CreateStringBuilder();
sb.Dispose();
sb.Dispose(); // call more than once
}
/// <summary>
/// Formats the specified text element.
/// </summary>
/// <param name="element">The element</param>
/// <returns></returns>
private static string FormatTextElement(XElement element)
{
var sb = ZString.CreateStringBuilder();
FormatTextElement(element, ref sb);
return(sb.ToString());
}
/// <summary>
/// Format it to a human-readable signature, like "AddValues<T>(IEnumerable<T>)".
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
public static string FormatToReadableSignature(this MethodInfo method)
{
var sb = ZString.CreateStringBuilder();
sb.Append(method.Name);
if (method.IsGenericMethod)
{
var genericArgs = method.GetGenericArguments();
if (genericArgs.Length > 0)
{
sb.Append("<");
for (int i = 0; i < genericArgs.Length; ++i)
{
if (i > 0)
{
sb.Append(", ");
}
sb.Append(genericArgs[i].FormatToReadableTypeName(false));
}
sb.Append(">");
}
}
var parameters = method.GetParameters();
if (parameters.Length > 0)
{
sb.Append("(");
for (int i = 0; i < parameters.Length; ++i)
{
if (i > 0)
{
sb.Append(", ");
}
if (parameters[i].IsIn)
{
sb.Append("in ");
}
if (parameters[i].IsOut)
{
sb.Append("out ");
}
sb.Append(parameters[i].ParameterType.FormatToReadableTypeName(false));
}
sb.Append(")");
}
return(sb.ToString());
}
public void NotMatchTest()
{
using (var zsb = ZString.CreateStringBuilder(notNested: true))
{
var text = "The quick brown dog jumps over the lazy cat.";
zsb.Append(text);
zsb.Replace("pig", "dog");
zsb.ToString().Should().Be(text);
}
}
public void NotInserted()
{
using (var zsb = ZString.CreateStringBuilder(notNested: true))
{
var text = "The quick brown dog jumps over the lazy cat.";
zsb.Append(text);
zsb.Insert(10, "");
zsb.ToString().Should().Be(text);
}
}
private static string CreateQueryStringTokenKey(IEnumerable <string> values)
{
using var builder = ZString.CreateStringBuilder();
builder.Append(TokenCacheKeyPrefix);
foreach (var item in values)
{
builder.Append(item);
}
return(builder.ToString());
}
