/// <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()); }