public int Utf8StringBuilderAppendFormat_()
{
using var zsh = ZString.CreateUtf8StringBuilder();
zsh.AppendFormat(_format,
_byte, _dt, _dto, _decimal, _double, _guid, _short, _float, _ts, _uint, _ulong, _null, _string, _bool, _enum, _char);
return(zsh.Length);
}
public void JoinOverloads3()
{
ZString.Join(',', new string[] { }.ToList()).Should().Be(string.Join(',', new string[0]));
ZString.Join(',', new[] { 1 }.ToList()).Should().Be(string.Join(',', new[] { 1 }));
ZString.Join(',', new[] { 1, 2 }.ToList()).Should().Be(string.Join(',', new[] { 1, 2 }));
ZString.Join(',', new[] { 1, 2, 3 }.ToList()).Should().Be(string.Join(',', new[] { 1, 2, 3 }));
ZString.Join(',', (IList <int>) new int[] { }).Should().Be(string.Join(',', new string[0]));
ZString.Join(',', (IList <int>) new[] { 1 }).Should().Be(string.Join(',', new[] { 1 }));
ZString.Join(',', (IList <int>) new[] { 1, 2 }).Should().Be(string.Join(',', new[] { 1, 2 }));
ZString.Join(',', (IList <int>) new[] { 1, 2, 3 }).Should().Be(string.Join(',', new[] { 1, 2, 3 }));
ZString.Join(',', (IReadOnlyList <int>) new int[] { }).Should().Be(string.Join(',', new string[0]));
ZString.Join(',', (IReadOnlyList <int>) new[] { 1 }).Should().Be(string.Join(',', new[] { 1 }));
ZString.Join(',', (IReadOnlyList <int>) new[] { 1, 2 }).Should().Be(string.Join(',', new[] { 1, 2 }));
ZString.Join(',', (IReadOnlyList <int>) new[] { 1, 2, 3 }).Should().Be(string.Join(',', new[] { 1, 2, 3 }));
ZString.Join(',', (ICollection <int>) new int[] { }).Should().Be(string.Join(',', new string[0]));
ZString.Join(',', (ICollection <int>) new[] { 1 }).Should().Be(string.Join(',', new[] { 1 }));
ZString.Join(',', (ICollection <int>) new[] { 1, 2 }).Should().Be(string.Join(',', new[] { 1, 2 }));
ZString.Join(',', (ICollection <int>) new[] { 1, 2, 3 }).Should().Be(string.Join(',', new[] { 1, 2, 3 }));
ZString.Join(',', (IReadOnlyCollection <int>) new int[] { }).Should().Be(string.Join(',', new string[0]));
ZString.Join(',', (IReadOnlyCollection <int>) new[] { 1 }).Should().Be(string.Join(',', new[] { 1 }));
ZString.Join(',', (IReadOnlyCollection <int>) new[] { 1, 2 }).Should().Be(string.Join(',', new[] { 1, 2 }));
ZString.Join(',', (IReadOnlyCollection <int>) new[] { 1, 2, 3 }).Should().Be(string.Join(',', new[] { 1, 2, 3 }));
}
private int MakeString(IntPtr src, UIntPtr byteCount, ref IntPtr newZString, ZStringFormat format)
{
if (src != IntPtr.Zero)
{
ulong stringLength = byteCount.ToUInt64();
if (stringLength == 0)
{
newZString = Empty;
}
else
{
// The framework cannot create a string longer than Int32.MaxValue.
if (stringLength > int.MaxValue)
{
return(PSError.kASOutOfMemory);
}
try
{
ZString zstring = new ZString(src, (int)stringLength, format);
newZString = GenerateDictionaryKey();
strings.Add(newZString, zstring);
}
catch (OutOfMemoryException)
{
return(PSError.kASOutOfMemory);
}
}
return(PSError.kASNoError);
}
return(PSError.kASBadParameter);
}
static void Utf8 <T>(T e) where T : Enum
{
var s = ZString.CreateUtf8StringBuilder();
s.AppendFormat("{0}", e);
s.AsSpan().SequenceEqual(Encoding.UTF8.GetBytes(e.ToString())).Should().BeTrue();
}
/// <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 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
}
static void Run()
{
var a = new string('a', 10000);
var b = new string('b', 1000000);
ZString.Join(',', new string[] { a, b });
}
/// <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 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());
}
}
public static IServiceCollection AddDFrameHosting(this IServiceCollection services)
{
return(services.AddDFrameHosting(new ZLoggerOptions
{
ExceptionFormatter = (writer, ex) => ZString.Utf8Format(writer, "{0} {1}", ex.Message, ex.StackTrace),
}));
}
public void TextOptions()
{
var options = new ZLoggerOptions()
{
PrefixFormatter = (writer, info) => ZString.Utf8Format(writer, "[Pre:{0}]", info.LogLevel),
SuffixFormatter = (writer, info) => ZString.Utf8Format(writer, "[Suf:{0}]", info.CategoryName),
ExceptionFormatter = (writer, ex) => ZString.Utf8Format(writer, "{0}", ex.Message)
};
var processsor = new TestProcessor(options);
var loggerFactory = LoggerFactory.Create(x =>
{
x.SetMinimumLevel(LogLevel.Debug);
x.AddZLoggerLogProcessor(processsor);
});
var logger = loggerFactory.CreateLogger("test");
logger.ZLogDebug("FooBar{0}-NanoNano{1}", 100, 200);
processsor.Dequeue().Should().Be("[Pre:Debug]FooBar100-NanoNano200[Suf:test]");
logger.ZLogInformation("FooBar{0}-NanoNano{1}", 100, 300);
processsor.Dequeue().Should().Be("[Pre:Information]FooBar100-NanoNano300[Suf:test]");
// fallback case
logger.LogDebug("FooBar{0}-NanoNano{1}", 100, 200);
processsor.Dequeue().Should().Be("[Pre:Debug]FooBar100-NanoNano200[Suf:test]");
logger.LogInformation("FooBar{0}-NanoNano{1}", 100, 300);
processsor.Dequeue().Should().Be("[Pre:Information]FooBar100-NanoNano300[Suf:test]");
}
/// <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());
}
}
static GitRevision()
{
DotnetRuntime = ZString.Format("Runtime: {0} (Mode: {1}) ",
RuntimeInformation.FrameworkDescription,
Environment.Version.Major >= 6 && !RuntimeFeature.IsDynamicCodeSupported ? "NativeAOT" : "JIT"
);
if (OperatingSystem.IsWindows())
{
if (Environment.Is64BitOperatingSystem)
{
OSPlatform = "Win64";
}
else
{
OSPlatform = "Win32";
}
}
else if (OperatingSystem.IsMacOS())
{
OSPlatform = "macOS";
}
else
{
OSPlatform = "Unix";
}
#if DEBUG
var buildConfiguration = "Debug";
#else
var buildConfiguration = "Release";
#endif
FullVersion = $"FelCore rev. {Hash} {Date} ({Branch} branch) ({OSPlatform}, {buildConfiguration})";
}
/// <summary>
/// 仿MyBatis CRUD 更符合nameof规范
/// </summary>
public TableQueryCustom WhereEqual(string where, object value)
{
var query = ZString.Format("{0} = {1}", where, value);
this.@where = ZString.Concat(this.@where, " ", query);
return(this);
}
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);
}
/// <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);
}
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()));
}
}
public void Utf8DisposeTest()
{
var sb = ZString.CreateUtf8StringBuilder();
sb.Dispose();
sb.Dispose(); // call more than once
}
/// <summary>
/// API shim for using <see cref="Text"/> with mutable string
/// </summary>
public static void SetZString(this Text text, ZString zString)
{
text.text = zString.ToString();
text.cachedTextGenerator.Invalidate();
text.SetLayoutDirty();
text.SetVerticesDirty();
}
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
}
/// <summary>
/// 加载普通资源
/// </summary>
/// <param name="name"></param>
/// <param name="type"></param>
/// <returns></returns>
public Object LoadAsset(string name, Type type)
{
string fullName = "";
if (!assetNameMap.TryGetValue(name, out fullName))
{
var fs = this.AssetBundle.GetAllAssetNames();
if (fs.Length == 1)
{
fullName = fs[0];
}
else
{
var subPath = ZString.Concat("/", name, ".");
fullName = fs.FirstOrDefault((p) => p.Contains(subPath, StringComparison.OrdinalIgnoreCase));
}
assetNameMap[name] = fullName;
}
if (fullName == null)
{
return(null);
}
var go = this.AssetBundle.LoadAsset(fullName, type);
return(go);
}
/// <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 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();
}
}
private int Copy(IntPtr source, ref IntPtr zstrCopy)
{
if (source == Empty)
{
zstrCopy = Empty;
}
else
{
ZString existing;
if (strings.TryGetValue(source, out existing))
{
try
{
ZString zstring = new ZString(string.Copy(existing.Data));
zstrCopy = GenerateDictionaryKey();
strings.Add(zstrCopy, zstring);
}
catch (OutOfMemoryException)
{
return(PSError.kASOutOfMemory);
}
}
else
{
return(PSError.kASBadParameter);
}
}
return(PSError.kASNoError);
}
/// <summary>
/// 升序排序
/// </summary>
public TableQueryCustom OrderBy(string field)
{
var query = ZString.Format(" Order By {0}", field);
this.@where = ZString.Concat(this.@where, query);
return(this);
}
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());
}
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());
}
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>()
.UseUrls("http://*:8081");
})
.ConfigureLogging((context, builder) =>
{
builder.ClearProviders();
if (context.HostingEnvironment.IsProduction())
{
//TODO..
}
builder.AddZLoggerConsole(options =>
{
options.PrefixFormatter = (writer, info) => ZString.Utf8Format(writer, "[{0}] [{1}] ", info.LogLevel.ToUpperString(), info.Timestamp.ToLocalTime().DateTime);
});
builder.AddZLoggerRollingFile((dt, x) => $"logs/{dt.ToLocalTime():yyyy-MM-dd}_{x:000}.log", x => x.ToLocalTime().Date, 1024 * 10,
options =>
{
options.PrefixFormatter = (writer, info) => ZString.Utf8Format(writer, "[{0}] [{1}] ", info.LogLevel.ToUpperString(), info.Timestamp.ToLocalTime().DateTime);
});
})
.ConfigureServices((context,
collection) => collection
.Configure <MongoSettings>((settings) =>
{
settings = context.Configuration.GetSection("MongoSettings").Get <MongoSettings>();
}));
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()));
}
}
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()));
}
}
private ZValue ReadZValueFromBsonDocument(BsonReader bsonReader)
{
// { "_t" : "ZString", "value" : "" }
bsonReader.ReadStartDocument();
BsonType type = bsonReader.ReadBsonType();
if (type != BsonType.String)
throw new PBException("error reading ZValue can't find ZValue type \"_t\"");
string name = bsonReader.ReadName();
if (name != "_t")
throw new PBException("error reading ZValue can't find ZValue type \"_t\"");
string typeName = bsonReader.ReadString();
type = bsonReader.ReadBsonType();
name = bsonReader.ReadName();
if (name != "value")
throw new PBException("error reading ZValue can't find ZValue value \"value\"");
ZValue value = null;
switch (typeName)
{
case "ZString":
if (type != BsonType.String)
throw new PBException("error reading ZString value is'nt a string ({0})", type);
value = new ZString(bsonReader.ReadString());
break;
//case "ZStringArray":
// if (type != BsonType.Array)
// throw new PBException("error reading ZStringArray value is'nt an array ({0})", type);
// value = new ZString(bsonReader.ReadString());
// break;
case "ZInt":
if (type != BsonType.Int32)
throw new PBException("error reading ZInt value is'nt an int32 ({0})", type);
value = new ZInt(bsonReader.ReadInt32());
break;
default:
throw new PBException("error reading ZValue type \"{0}\" is'nt a ZValue type", typeName);
}
type = bsonReader.ReadBsonType();
if (type != BsonType.EndOfDocument)
throw new PBException("error reading ZValue cant find end of document ({0})", type);
bsonReader.ReadEndDocument();
return value;
}
/// <summary>
/// API shim for using <see cref="Text"/> with mutable string
/// </summary>
public static void SetZString(this Text text, ZString zString)
{
text.text = zString.ToString();
text.cachedTextGenerator.Invalidate();
text.SetLayoutDirty();
text.SetVerticesDirty();
}
