Make encoding more explicit with an enum

Genbox · Genbox · commit 937c9cccc335 · 2025-07-08T19:36:11.000+02:00
diff --git a/Src/FastData.Benchmarks/Benchmarks/AnalyzerBenchmarks.cs b/Src/FastData.Benchmarks/Benchmarks/AnalyzerBenchmarks.cs
@@ -1,3 +1,4 @@
+using Genbox.FastData.Enums;
 using Genbox.FastData.Internal.Analysis;
 using Genbox.FastData.Internal.Analysis.Analyzers;
 using Genbox.FastData.Internal.Analysis.Properties;
@@ -18,7 +19,7 @@ public AnalyzerBenchmarks()
         _data = Enumerable.Range(1, 100).Select(_ => TestHelper.GenerateRandomString(rng, 50)).ToArray();
 
         StringProperties props = DataAnalyzer.GetStringProperties(_data);
-        _analyzer = new GPerfAnalyzer(_data.Length, props, new GPerfAnalyzerConfig(), new Simulator(_data.Length, true), NullLogger<GPerfAnalyzer>.Instance);
+        _analyzer = new GPerfAnalyzer(_data.Length, props, new GPerfAnalyzerConfig(), new Simulator(_data.Length, GeneratorEncoding.UTF16), NullLogger<GPerfAnalyzer>.Instance);
     }
 
     [Benchmark]
diff --git a/Src/FastData.Generator.CPlusPlus/Internal/Framework/CPlusPlusLanguageDef.cs b/Src/FastData.Generator.CPlusPlus/Internal/Framework/CPlusPlusLanguageDef.cs
@@ -5,7 +5,7 @@ namespace Genbox.FastData.Generator.CPlusPlus.Internal.Framework;
 
 internal class CPlusPlusLanguageDef : ILanguageDef
 {
-    public bool UseUTF16Encoding => true;
+    public GeneratorEncoding Encoding => GeneratorEncoding.UTF16;
     public string ArraySizeType => "size_t";
 
     public IList<ITypeDef> TypeDefinitions => new List<ITypeDef>
diff --git a/Src/FastData.Generator.CSharp/Internal/Framework/CSharpLanguageDef.cs b/Src/FastData.Generator.CSharp/Internal/Framework/CSharpLanguageDef.cs
@@ -5,7 +5,7 @@ namespace Genbox.FastData.Generator.CSharp.Internal.Framework;
 
 internal class CSharpLanguageDef : ILanguageDef
 {
-    public bool UseUTF16Encoding => true;
+    public GeneratorEncoding Encoding => GeneratorEncoding.UTF16;
     public string ArraySizeType => "uint";
 
     public IList<ITypeDef> TypeDefinitions => new List<ITypeDef>
diff --git a/Src/FastData.Generator.Rust/Internal/Framework/RustLanguageDef.cs b/Src/FastData.Generator.Rust/Internal/Framework/RustLanguageDef.cs
@@ -5,7 +5,7 @@ namespace Genbox.FastData.Generator.Rust.Internal.Framework;
 
 internal class RustLanguageDef : ILanguageDef
 {
-    public bool UseUTF16Encoding => false;
+    public GeneratorEncoding Encoding => GeneratorEncoding.UTF8;
     public string ArraySizeType => "usize";
 
     public IList<ITypeDef> TypeDefinitions => new List<ITypeDef>
diff --git a/Src/FastData.Generator/Framework/CodeGenerator.cs b/Src/FastData.Generator/Framework/CodeGenerator.cs
@@ -34,7 +34,7 @@ protected CodeGenerator(ILanguageDef langDef, IConstantsDef constDef, IEarlyExit
 
     protected SharedCode Shared { get; }
 
-    public bool UseUTF16Encoding => _langDef.UseUTF16Encoding;
+    public GeneratorEncoding Encoding => _langDef.Encoding;
 
     public virtual string Generate<T>(ReadOnlySpan<T> data, GeneratorConfig<T> genCfg, IContext<T> context) where T : notnull
     {
diff --git a/Src/FastData.Generator/Framework/Interfaces/ILanguageDef.cs b/Src/FastData.Generator/Framework/Interfaces/ILanguageDef.cs
@@ -1,8 +1,10 @@
+using Genbox.FastData.Enums;
+
 namespace Genbox.FastData.Generator.Framework.Interfaces;
 
 public interface ILanguageDef
 {
-    bool UseUTF16Encoding { get; }
+    GeneratorEncoding Encoding { get; }
     IList<ITypeDef> TypeDefinitions { get; }
     string ArraySizeType { get; }
 }
diff --git a/Src/FastData.InternalShared/DummyGenerator.cs b/Src/FastData.InternalShared/DummyGenerator.cs
@@ -1,3 +1,4 @@
+using Genbox.FastData.Enums;
 using Genbox.FastData.Generators;
 using Genbox.FastData.Generators.Abstracts;
 using Newtonsoft.Json;
@@ -6,9 +7,9 @@ namespace Genbox.FastData.InternalShared;
 
 public readonly struct DummyGenerator : ICodeGenerator
 {
-    public bool UseUTF16Encoding => true;
+    public GeneratorEncoding Encoding => GeneratorEncoding.Unknown;
 
-    public string Generate<T>(ReadOnlySpan<T> data, GeneratorConfig<T> genCfg, IContext<T> context)
+    public string Generate<T>(ReadOnlySpan<T> data, GeneratorConfig<T> genCfg, IContext<T> context) where T : notnull
     {
         Combined<T> combined = new Combined<T>(data.ToArray(), context);
         return JsonConvert.SerializeObject(combined, new JsonSerializerSettings { Formatting = Formatting.Indented });
diff --git a/Src/FastData.InternalShared/Helpers/TestHelper.cs b/Src/FastData.InternalShared/Helpers/TestHelper.cs
@@ -107,7 +107,7 @@ public static GeneratorSpec Generate<T>(Func<string, ICodeGenerator> func, TestV
             props = DataAnalyzer.GetValueProperties(span, dataType);
 
         ICodeGenerator generator = func(vector.Identifier);
-        bool useUTF16 = generator.UseUTF16Encoding;
+        GeneratorEncoding encoding = generator.Encoding;
 
         if (vector.Type == typeof(SingleValueStructure<>))
             return Generate(generator, vector, props, dataType, StructureType.Auto, new SingleValueStructure<T>());
@@ -120,25 +120,25 @@ public static GeneratorSpec Generate<T>(Func<string, ICodeGenerator> func, TestV
         if (vector.Type == typeof(EytzingerSearchStructure<>))
             return Generate(generator, vector, props, dataType, StructureType.BinarySearch, new EytzingerSearchStructure<T>(dataType, StringComparison.Ordinal));
         if (vector.Type == typeof(HashSetChainStructure<>))
-            return Generate(generator, vector, props, dataType, StructureType.HashSet, new HashSetChainStructure<T>(GetHashData(vector, dataType, useUTF16), dataType));
+            return Generate(generator, vector, props, dataType, StructureType.HashSet, new HashSetChainStructure<T>(GetHashData(vector, dataType, encoding), dataType));
         if (vector.Type == typeof(HashSetPerfectStructure<>))
-            return Generate(generator, vector, props, dataType, StructureType.HashSet, new HashSetPerfectStructure<T>(GetHashData(vector, dataType, useUTF16), dataType));
+            return Generate(generator, vector, props, dataType, StructureType.HashSet, new HashSetPerfectStructure<T>(GetHashData(vector, dataType, encoding), dataType));
         if (vector.Type == typeof(HashSetLinearStructure<>))
-            return Generate(generator, vector, props, dataType, StructureType.HashSet, new HashSetLinearStructure<T>(GetHashData(vector, dataType, useUTF16)));
+            return Generate(generator, vector, props, dataType, StructureType.HashSet, new HashSetLinearStructure<T>(GetHashData(vector, dataType, encoding)));
         if (vector.Type == typeof(KeyLengthStructure<>))
             return Generate(generator, vector, props, dataType, StructureType.Auto, new KeyLengthStructure<T>((StringProperties)props));
 
         throw new InvalidOperationException("Unsupported structure type: " + vector.Type.Name);
     }
 
-    private static HashData GetHashData<T>(TestVector<T> vector, DataType dataType, bool useUTF16) where T : notnull
+    private static HashData GetHashData<T>(TestVector<T> vector, DataType dataType, GeneratorEncoding genEnc) where T : notnull
     {
         HashData hashData;
 
         if (dataType == DataType.String)
         {
-            Encoding encoding = useUTF16 ? Encoding.Unicode : Encoding.UTF8;
-            StringHashFunc func = DefaultStringHash.GetInstance(useUTF16).GetExpression().Compile();
+            Encoding encoding = genEnc == GeneratorEncoding.UTF8 ? Encoding.UTF8 : Encoding.Unicode;
+            StringHashFunc func = DefaultStringHash.GetInstance(genEnc).GetExpression().Compile();
 
             hashData = HashData.Create<T>(vector.Values.AsSpan(), 1, obj =>
             {
@@ -161,7 +161,7 @@ private static GeneratorSpec Generate<T, TContext>(ICodeGenerator generator, Tes
         HashDetails hashDetails = new HashDetails();
 
         if (props is StringProperties stringProps)
-            genCfg = new GeneratorConfig<T>(structureType, dataType, (uint)vector.Values.Length, stringProps, StringComparison.Ordinal, hashDetails, generator.UseUTF16Encoding);
+            genCfg = new GeneratorConfig<T>(structureType, dataType, (uint)vector.Values.Length, stringProps, StringComparison.Ordinal, hashDetails, generator.Encoding);
         else if (props is ValueProperties<T> valueProps)
         {
             hashDetails.HasZeroOrNaN = valueProps.HasZeroOrNaN;
diff --git a/Src/FastData.Testbed/Tests/AnalysisTest.cs b/Src/FastData.Testbed/Tests/AnalysisTest.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using Genbox.FastData.Enums;
 using Genbox.FastData.Generators.StringHash;
 using Genbox.FastData.Internal.Analysis;
 using Genbox.FastData.Internal.Analysis.Analyzers;
@@ -56,7 +57,7 @@ public static void TestBest()
                 gcfg.PopulationSize = j;
 
                 sw.Restart();
-                Candidate cand = FastDataGenerator.GetBestHash(Data, props, cfg, NullLoggerFactory.Instance, true, false);
+                Candidate cand = FastDataGenerator.GetBestHash(Data, props, cfg, NullLoggerFactory.Instance, GeneratorEncoding.UTF16, false);
 
                 sw.Stop();
                 Console.WriteLine($"{i.ToString(),-10}{j.ToString(),-10}{sw.ElapsedMilliseconds,-10:N0}{cand.Collisions,-10:N0}");
@@ -69,7 +70,7 @@ public static void TestNoAnalyzer()
         string[] data = RunFunc(Data, 5.0, PrependString).ToArray();
         Print(data, "DefaultHash");
 
-        Simulator sim = new Simulator(data.Length, true);
+        Simulator sim = new Simulator(data.Length, GeneratorEncoding.UTF16);
         PrintCandidate(sim.Run(data, DefaultStringHash.UTF16Instance));
     }
 
@@ -106,7 +107,7 @@ private static void RunBruteForce(string[] data, [CallerArgumentExpression(nameo
 
         StringProperties props = DataAnalyzer.GetStringProperties(data);
         using SerilogLoggerFactory loggerFactory = new SerilogLoggerFactory(_logConf);
-        BruteForceAnalyzer analyzer = new BruteForceAnalyzer(props, new BruteForceAnalyzerConfig(), new Simulator(data.Length, true), loggerFactory.CreateLogger<BruteForceAnalyzer>());
+        BruteForceAnalyzer analyzer = new BruteForceAnalyzer(props, new BruteForceAnalyzerConfig(), new Simulator(data.Length, GeneratorEncoding.UTF16), loggerFactory.CreateLogger<BruteForceAnalyzer>());
         PrintCandidate(analyzer.GetCandidates(data).OrderByDescending(x => x.Fitness).FirstOrDefault());
     }
 
@@ -116,7 +117,7 @@ private static void RunGeneticAnalysis(string[] data, [CallerArgumentExpression(
 
         StringProperties props = DataAnalyzer.GetStringProperties(data);
         using SerilogLoggerFactory loggerFactory = new SerilogLoggerFactory(_logConf);
-        GeneticAnalyzer analyzer = new GeneticAnalyzer(props, new GeneticAnalyzerConfig(), new Simulator(data.Length, true), loggerFactory.CreateLogger<GeneticAnalyzer>());
+        GeneticAnalyzer analyzer = new GeneticAnalyzer(props, new GeneticAnalyzerConfig(), new Simulator(data.Length, GeneratorEncoding.UTF16), loggerFactory.CreateLogger<GeneticAnalyzer>());
         PrintCandidate(analyzer.GetCandidates(data).OrderByDescending(x => x.Fitness).FirstOrDefault());
     }
 
@@ -126,7 +127,7 @@ private static void RunGPerfAnalysis(string[] data, [CallerArgumentExpression(na
 
         StringProperties props = DataAnalyzer.GetStringProperties(data);
         using SerilogLoggerFactory loggerFactory = new SerilogLoggerFactory(_logConf);
-        GPerfAnalyzer analyzer = new GPerfAnalyzer(data.Length, props, new GPerfAnalyzerConfig(), new Simulator(data.Length, true), loggerFactory.CreateLogger<GPerfAnalyzer>());
+        GPerfAnalyzer analyzer = new GPerfAnalyzer(data.Length, props, new GPerfAnalyzerConfig(), new Simulator(data.Length, GeneratorEncoding.UTF16), loggerFactory.CreateLogger<GPerfAnalyzer>());
         PrintCandidate(analyzer.GetCandidates(data).OrderByDescending(x => x.Fitness).FirstOrDefault());
     }
 
diff --git a/Src/FastData.Testbed/Tests/GPerfTest.cs b/Src/FastData.Testbed/Tests/GPerfTest.cs
@@ -44,7 +44,7 @@ public static void ProduceOutputs(string path)
             ReadOnlySpan<string> data = File.ReadAllLines(file).AsSpan();
             StringProperties props = DataAnalyzer.GetStringProperties(data);
 
-            GPerfAnalyzer analyzer = new GPerfAnalyzer(data.Length, props, new GPerfAnalyzerConfig(), new Simulator(data.Length, true), factory.CreateLogger<GPerfAnalyzer>());
+            GPerfAnalyzer analyzer = new GPerfAnalyzer(data.Length, props, new GPerfAnalyzerConfig(), new Simulator(data.Length, GeneratorEncoding.UTF16), factory.CreateLogger<GPerfAnalyzer>());
             Candidate cand = analyzer.GetCandidates(data).First();
             StringHashFunc func = cand.StringHash.GetExpression().Compile();
 
diff --git a/Src/FastData/Enums/GeneratorEncoding.cs b/Src/FastData/Enums/GeneratorEncoding.cs
@@ -0,0 +1,8 @@
+namespace Genbox.FastData.Enums;
+
+public enum GeneratorEncoding : byte
+{
+    Unknown = 0,
+    UTF8,
+    UTF16
+}
diff --git a/Src/FastData/FastDataGenerator.cs b/Src/FastData/FastDataGenerator.cs
@@ -179,7 +179,7 @@ private static string GenerateString(ReadOnlySpan<string> data, FastDataConfig f
 
         StringProperties strProps = DataAnalyzer.GetStringProperties(data);
         LogMinMaxLength(logger, strProps.LengthData.Min, strProps.LengthData.Max);
-        GeneratorConfig<string> genCfg = new GeneratorConfig<string>(fdCfg.StructureType, dataType, (uint)data.Length, strProps, DefaultStringComparison, hashDetails, generator.UseUTF16Encoding);
+        GeneratorConfig<string> genCfg = new GeneratorConfig<string>(fdCfg.StructureType, dataType, (uint)data.Length, strProps, DefaultStringComparison, hashDetails, generator.Encoding);
 
         switch (fdCfg.StructureType)
         {
@@ -212,7 +212,7 @@ private static string GenerateString(ReadOnlySpan<string> data, FastDataConfig f
 
                 if (fdCfg.StringAnalyzerConfig != null)
                 {
-                    Candidate candidate = GetBestHash(data, strProps, fdCfg.StringAnalyzerConfig, factory, generator.UseUTF16Encoding, true);
+                    Candidate candidate = GetBestHash(data, strProps, fdCfg.StringAnalyzerConfig, factory, generator.Encoding, true);
                     LogStringHashFitness(logger, candidate.Fitness);
 
                     Expression<StringHashFunc> expression = candidate.StringHash.GetExpression();
@@ -222,14 +222,14 @@ private static string GenerateString(ReadOnlySpan<string> data, FastDataConfig f
                 }
                 else
                 {
-                    hashFunc = DefaultStringHash.GetInstance(generator.UseUTF16Encoding).GetExpression().Compile();
+                    hashFunc = DefaultStringHash.GetInstance(generator.Encoding).GetExpression().Compile();
 
                     //We do not set hashDetails.StringHash here, as the user requested it to be disabled
                 }
 
                 HashData hashData = HashData.Create(data, fdCfg.HashCapacityFactor, x =>
                 {
-                    byte[] bytes = generator.UseUTF16Encoding ? Encoding.Unicode.GetBytes(x) : Encoding.UTF8.GetBytes(x);
+                    byte[] bytes = generator.Encoding == GeneratorEncoding.UTF8 ? Encoding.UTF8.GetBytes(x) : Encoding.Unicode.GetBytes(x);
                     return hashFunc(bytes, bytes.Length);
                 });
 
@@ -259,16 +259,16 @@ private static ReadOnlySpan<T> Cast<T>(this ReadOnlySpan<object> data) where T :
         return newArr;
     }
 
-    internal static Candidate GetBestHash(ReadOnlySpan<string> data, StringProperties props, StringAnalyzerConfig cfg, ILoggerFactory factory, bool useUTF16, bool includeDefault)
+    internal static Candidate GetBestHash(ReadOnlySpan<string> data, StringProperties props, StringAnalyzerConfig cfg, ILoggerFactory factory, GeneratorEncoding encoding, bool includeDefault)
     {
-        Simulator sim = new Simulator(data.Length, useUTF16);
+        Simulator sim = new Simulator(data.Length, encoding);
 
         //Run each of the analyzers
         List<Candidate> candidates = new List<Candidate>();
 
         //We always add the default hash as a candidate
         if (includeDefault)
-            candidates.Add(sim.Run(data, DefaultStringHash.GetInstance(useUTF16)));
+            candidates.Add(sim.Run(data, DefaultStringHash.GetInstance(encoding)));
 
         if (cfg.BruteForceAnalyzerConfig != null)
         {
@@ -308,7 +308,7 @@ internal static Candidate GetBestHash(ReadOnlySpan<string> data, StringPropertie
         notPerfect.Sort(static (a, b) => b.Fitness.CompareTo(a.Fitness));
 
         string test = new string('a', (int)props.LengthData.Max);
-        byte[] testBytes = useUTF16 ? Encoding.Unicode.GetBytes(test) : Encoding.UTF8.GetBytes(test);
+        byte[] testBytes = encoding == GeneratorEncoding.UTF8 ? Encoding.UTF8.GetBytes(test) : Encoding.Unicode.GetBytes(test);
 
         //We start with the perfect results (if any)
         if (perfect.Count > 0)
diff --git a/Src/FastData/Generators/Abstracts/ICodeGenerator.cs b/Src/FastData/Generators/Abstracts/ICodeGenerator.cs
@@ -1,10 +1,12 @@
+using Genbox.FastData.Enums;
+
 namespace Genbox.FastData.Generators.Abstracts;
 
 /// <summary>Defines the interface for code generators</summary>
 public interface ICodeGenerator
 {
     /// <summary>Gets a value indicating whether the generator uses UTF-16 encoding for string inputs (used in hashing).</summary>
-    bool UseUTF16Encoding { get; }
+    GeneratorEncoding Encoding { get; }
 
     /// <summary>Attempts to generate source code using the specified generator configuration and context.</summary>
     /// <typeparam name="T">The type of data being generated.</typeparam>
diff --git a/Src/FastData/Generators/GeneratorConfig.cs b/Src/FastData/Generators/GeneratorConfig.cs
@@ -24,9 +24,9 @@ internal GeneratorConfig(StructureType structureType, DataType dataType, uint it
         Constants = CreateConstants(props, itemCount);
     }
 
-    internal GeneratorConfig(StructureType structureType, DataType dataType, uint itemCount, StringProperties props, StringComparison stringComparison, HashDetails hashDetails, bool useUtf16) : this(structureType, dataType, hashDetails)
+    internal GeneratorConfig(StructureType structureType, DataType dataType, uint itemCount, StringProperties props, StringComparison stringComparison, HashDetails hashDetails, GeneratorEncoding encoding) : this(structureType, dataType, hashDetails)
     {
-        EarlyExits = GetEarlyExits(props, itemCount, structureType, useUtf16).ToArray();
+        EarlyExits = GetEarlyExits(props, itemCount, structureType, encoding).ToArray();
         Constants = CreateConstants(props, itemCount);
         StringComparison = stringComparison;
     }
@@ -68,7 +68,7 @@ private static Constants<T> CreateConstants(StringProperties props, uint itemCou
         return constants;
     }
 
-    private static IEnumerable<IEarlyExit> GetEarlyExits(StringProperties props, uint itemCount, StructureType structureType, bool useUtf16)
+    private static IEnumerable<IEarlyExit> GetEarlyExits(StringProperties props, uint itemCount, StructureType structureType, GeneratorEncoding enc)
     {
         //There is no point to using early exists if there is just one item
         if (itemCount == 1)
@@ -87,8 +87,8 @@ private static IEnumerable<IEarlyExit> GetEarlyExits(StringProperties props, uin
             yield return new LengthBitSetEarlyExit(props.LengthData.LengthMap.FirstValue);
         else
         {
-            uint minByteCount = useUtf16 ? props.LengthData.MinUtf16ByteCount : props.LengthData.MinUtf8ByteCount;
-            uint maxByteCount = useUtf16 ? props.LengthData.MaxUtf16ByteCount : props.LengthData.MaxUtf8ByteCount;
+            uint minByteCount = enc == GeneratorEncoding.UTF8 ? props.LengthData.MinUtf8ByteCount : props.LengthData.MinUtf16ByteCount;
+            uint maxByteCount = enc == GeneratorEncoding.UTF8 ? props.LengthData.MaxUtf8ByteCount : props.LengthData.MaxUtf16ByteCount;
 
             yield return new MinMaxLengthEarlyExit(props.LengthData.Min, props.LengthData.Max, minByteCount, maxByteCount); //Also handles same lengths
         }
diff --git a/Src/FastData/Generators/StringHash/DefaultStringHash.cs b/Src/FastData/Generators/StringHash/DefaultStringHash.cs
@@ -1,5 +1,6 @@
 using System.Linq.Expressions;
 using System.Text;
+using Genbox.FastData.Enums;
 using Genbox.FastData.Generators.StringHash.Framework;
 using Genbox.FastData.Internal.Abstracts;
 using Genbox.FastData.Internal.Analysis.Expressions;
@@ -10,17 +11,17 @@ namespace Genbox.FastData.Generators.StringHash;
 /// <summary>Hashes the entire string using DJB2 hash</summary>
 internal sealed record DefaultStringHash : IStringHash
 {
-    private readonly bool _useUTF16;
+    private readonly GeneratorEncoding _encoding;
 
-    private DefaultStringHash(bool useUTF16) => _useUTF16 = useUTF16;
+    private DefaultStringHash(GeneratorEncoding encoding) => _encoding = encoding;
 
-    internal static DefaultStringHash UTF16Instance { get; } = new DefaultStringHash(true);
-    internal static DefaultStringHash UTF8Instance { get; } = new DefaultStringHash(false);
+    internal static DefaultStringHash UTF8Instance { get; } = new DefaultStringHash(GeneratorEncoding.UTF8);
+    internal static DefaultStringHash UTF16Instance { get; } = new DefaultStringHash(GeneratorEncoding.UTF16);
 
-    internal static DefaultStringHash GetInstance(bool useUTF16) => useUTF16 ? UTF16Instance : UTF8Instance;
+    internal static DefaultStringHash GetInstance(GeneratorEncoding enc) => enc == GeneratorEncoding.UTF8 ? UTF8Instance : UTF16Instance;
 
     public State[]? State => null;
-    public Expression<StringHashFunc> GetExpression() => ExpressionHashBuilder.BuildFull(Mixer, Avalanche, _useUTF16);
+    public Expression<StringHashFunc> GetExpression() => ExpressionHashBuilder.BuildFull(Mixer, Avalanche, _encoding);
     public ReaderFunctions Functions => ReaderFunctions.ReadU16;
 
     // (((hash << 5) | (hash >> 27)) + hash) ^ Read(data, offset)
diff --git a/Src/FastData/Internal/Analysis/Analyzers/Simulator.cs b/Src/FastData/Internal/Analysis/Analyzers/Simulator.cs
diff --git a/Src/FastData/Internal/Analysis/Expressions/ExpressionHashBuilder.cs b/Src/FastData/Internal/Analysis/Expressions/ExpressionHashBuilder.cs

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace Genbox.FastData.Generator.CPlusPlus.Internal.Framework;`
`5`	`5`
`6`	`6`	`internal class CPlusPlusLanguageDef : ILanguageDef`
`7`	`7`	`{`
`8`		`- public bool UseUTF16Encoding => true;`
	`8`	`+ public GeneratorEncoding Encoding => GeneratorEncoding.UTF16;`
`9`	`9`	`public string ArraySizeType => "size_t";`
`10`	`10`
`11`	`11`	`public IList<ITypeDef> TypeDefinitions => new List<ITypeDef>`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace Genbox.FastData.Generator.CSharp.Internal.Framework;`
`5`	`5`
`6`	`6`	`internal class CSharpLanguageDef : ILanguageDef`
`7`	`7`	`{`
`8`		`- public bool UseUTF16Encoding => true;`
	`8`	`+ public GeneratorEncoding Encoding => GeneratorEncoding.UTF16;`
`9`	`9`	`public string ArraySizeType => "uint";`
`10`	`10`
`11`	`11`	`public IList<ITypeDef> TypeDefinitions => new List<ITypeDef>`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace Genbox.FastData.Generator.Rust.Internal.Framework;`
`5`	`5`
`6`	`6`	`internal class RustLanguageDef : ILanguageDef`
`7`	`7`	`{`
`8`		`- public bool UseUTF16Encoding => false;`
	`8`	`+ public GeneratorEncoding Encoding => GeneratorEncoding.UTF8;`
`9`	`9`	`public string ArraySizeType => "usize";`
`10`	`10`
`11`	`11`	`public IList<ITypeDef> TypeDefinitions => new List<ITypeDef>`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ protected CodeGenerator(ILanguageDef langDef, IConstantsDef constDef, IEarlyExit`
`34`	`34`
`35`	`35`	`protected SharedCode Shared { get; }`
`36`	`36`
`37`		`- public bool UseUTF16Encoding => _langDef.UseUTF16Encoding;`
	`37`	`+ public GeneratorEncoding Encoding => _langDef.Encoding;`
`38`	`38`
`39`	`39`	`public virtual string Generate<T>(ReadOnlySpan<T> data, GeneratorConfig<T> genCfg, IContext<T> context) where T : notnull`
`40`	`40`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,10 @@`
	`1`	`+using Genbox.FastData.Enums;`
	`2`	`+`
`1`	`3`	`namespace Genbox.FastData.Generator.Framework.Interfaces;`
`2`	`4`
`3`	`5`	`public interface ILanguageDef`
`4`	`6`	`{`
`5`		`- bool UseUTF16Encoding { get; }`
	`7`	`+ GeneratorEncoding Encoding { get; }`
`6`	`8`	`IList<ITypeDef> TypeDefinitions { get; }`
`7`	`9`	`string ArraySizeType { get; }`
`8`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using Genbox.FastData.Enums;`
`1`	`2`	`using Genbox.FastData.Generators;`
`2`	`3`	`using Genbox.FastData.Generators.Abstracts;`
`3`	`4`	`using Newtonsoft.Json;`
`@@ -6,9 +7,9 @@ namespace Genbox.FastData.InternalShared;`
`6`	`7`
`7`	`8`	`public readonly struct DummyGenerator : ICodeGenerator`
`8`	`9`	`{`
`9`		`- public bool UseUTF16Encoding => true;`
	`10`	`+ public GeneratorEncoding Encoding => GeneratorEncoding.Unknown;`
`10`	`11`
`11`		`- public string Generate<T>(ReadOnlySpan<T> data, GeneratorConfig<T> genCfg, IContext<T> context)`
	`12`	`+ public string Generate<T>(ReadOnlySpan<T> data, GeneratorConfig<T> genCfg, IContext<T> context) where T : notnull`
`12`	`13`	`{`
`13`	`14`	`Combined<T> combined = new Combined<T>(data.ToArray(), context);`
`14`	`15`	`return JsonConvert.SerializeObject(combined, new JsonSerializerSettings { Formatting = Formatting.Indented });`