Moving codegen tools to another project

Example.Backend/Printer.cs

@@ -21,6 +21,12 @@ namespace Example.Backend
             return Task.CompletedTask;
         }
 
+        public Task IntTest(MyData data)
+        {
+            Console.WriteLine(data);
+            return Task.CompletedTask;
+        }
+
         public void OnPrintExternal(IPage p0, RequestContext ro)
         {
             OnPrint?.Invoke(p0, ro);

Example.Frontend/ClientBasedPrinter.cs

@@ -18,6 +18,11 @@ namespace Example.Frontend
             return Task.CompletedTask;
         }
 
+        public Task IntTest(MyData data)
+        {
+            throw new NotImplementedException();
+        }
+
         public void OnPrintExternal(IPage p0, RequestContext ro)
         {
         }

Example.Frontend/Program.cs

@@ -51,11 +51,9 @@ class Program
 
         using (var disposingPrinter = factory.Create("Test"))
         {
-            disposingPrinter.SetFingerPrint(new[] { 1, 2, 3 }).ContinueWith(r =>
+            disposingPrinter.SetFingerPrint(new[] { 1, 2, 3 }).ContinueWith(r => { Console.WriteLine(r.Status); });
-            {
-                Console.WriteLine(r.Status);
-            });
 
+            await disposingPrinter.IntTest(new MyData { Id = 5, Score = 7, Name = "Test" });
             DemoCheck.CreatingPrinter = true;
             disposingPrinter.OnPrint += (_, _) =>
             {
@@ -144,8 +142,5 @@ class Program
 
         DemoCheck.Show();
         Console.ReadKey();
-
-        
-        
     }
 }

Example.Shared/IPrinter.cs

@@ -13,8 +13,41 @@ namespace Example.Shared
         string GetName();
         Task<IPage> Print(string text, bool someParameter, RequestContext context, CancellationToken cancellationToken);
         event Action<IPage, RequestContext> OnPrint;
+
         [Untrusted]
         Task SomeoneIsApproaching(string humanName);
+
         Task SetFingerPrint(int[] fingerPrint);
+        Task IntTest(MyData data);
+    }
+
+    public class MyData
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public double Score { get; set; }
+
+        public override string ToString()
+        {
+            return $"{{{nameof(Id)}: {Id}, {nameof(Name)}: {Name}, {nameof(Score)}: {Score}}}";
+        }
+
+        protected bool Equals(MyData other)
+        {
+            return Id == other.Id && Name == other.Name && Score.Equals(other.Score);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is null) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != GetType()) return false;
+            return Equals((MyData)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Id, Name, Score);
+        }
     }
 }

mROA.Cbor/PreParsedValue.cs

@@ -65,7 +65,7 @@ namespace mROA.Cbor
                 property.SetValue(instance,
                     _properties[index] is IPreParsedValue ppv
                         ? ppv.ToObject(property.PropertyType, context)
-                        : _properties[index]);
+                        : Convert.ChangeType(_properties[index], property.PropertyType));
             }
 
             return instance;

mROA.Cbor/mROA.Cbor.csproj

@@ -4,7 +4,7 @@
         <TargetFramework>netstandard2.1</TargetFramework>
         <Nullable>enable</Nullable>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-        <Version>2.0.3</Version>
+        <Version>2.0.4</Version>
         <LangVersion>9</LangVersion>
     </PropertyGroup>
 

mROA.Codegen/mROA.Codegen.csproj

@@ -25,7 +25,7 @@
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0"/>
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.3.0" />
     </ItemGroup>
 
     <ItemGroup>

mROA.CodegenTools/DefineTemplateSection.cs

@@ -0,0 +1,30 @@
+namespace mROA.CodegenTools
+{
+    public class DefineTemplateSection : ITagged
+    {
+        public DefineTemplateSection(string storedText, string tag, TemplateDocument context)
+        {
+            StoredText = storedText;
+            Tag = tag;
+            Context = context;
+        }
+
+        public string StoredText { get; }
+        public TemplateDocument Context { get; set; }
+
+        public string Tag { get; }
+
+        public int TargetLength => StoredText.Length;
+
+        public object Clone()
+        {
+            return new DefineTemplateSection(StoredText, Tag, Context);
+        }
+
+
+        public override string ToString()
+        {
+            return StoredText;
+        }
+    }
+}

mROA.CodegenTools/ITemplateSection.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace mROA.CodegenTools
+{
+    public interface ITemplateSection : ICloneable
+    {
+        TemplateDocument Context { get; set; }
+        int TargetLength { get; }
+    }
+
+    public interface IBaking
+    {
+        string Bake();
+    }
+
+    public interface ITagged : ITemplateSection
+    {
+        string Tag { get; }
+    }
+}

mROA.CodegenTools/InnerTemplateSection.cs

@@ -0,0 +1,24 @@
+namespace mROA.CodegenTools
+{
+    public class InnerTemplateSection : ITemplateSection, ITagged
+    {
+        public InnerTemplateSection(string tag, TemplateDocument innerTemplate, TemplateDocument context)
+        {
+            Tag = tag;
+            Context = context;
+            InnerTemplate = innerTemplate;
+        }
+
+        public TemplateDocument InnerTemplate { get; }
+
+        public string Tag { get; }
+
+        public TemplateDocument Context { get; set; }
+        public int TargetLength => 0;
+
+        public object Clone()
+        {
+            return new InnerTemplateSection(Tag, InnerTemplate, Context);
+        }
+    }
+}

mROA.CodegenTools/InsertTemplateSection.cs

@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace mROA.CodegenTools
+{
+    public class InsertTemplateSection : ITagged, IBaking
+    {
+        public readonly List<string> Parameters;
+        private object _insertedValue;
+
+        public InsertTemplateSection(string tag, TemplateDocument context, params string[] parameters)
+        {
+            Tag = tag;
+            Parameters = parameters.ToList();
+            Context = context;
+        }
+
+        public string Bake()
+        {
+            switch (_insertedValue)
+            {
+                case null:
+                    return string.Empty;
+                case string s:
+                    return s;
+                default:
+                    return ((ITemplateSection)_insertedValue).ToString();
+            }
+        }
+
+        public string Tag { get; private set; }
+
+        public TemplateDocument Context { get; set; }
+
+
+        public int TargetLength => 0;
+
+        public object Clone()
+        {
+            return new InsertTemplateSection(Tag, Context, Parameters.ToArray());
+        }
+
+        private bool IsInserted(object value)
+        {
+            if (Parameters.IndexOf("r") == -1) return false;
+
+            ProduceInserted(value);
+
+            return true;
+        }
+
+        private void ProduceInserted(object value)
+        {
+            var currentIndex = Context.Parts.IndexOf(this);
+            var clone = (InsertTemplateSection)MemberwiseClone();
+            clone.Tag += "+";
+
+            clone._insertedValue = value;
+
+            Context.Parts.Insert(currentIndex, clone);
+
+            InsertSeparator(currentIndex + 1);
+        }
+
+        private void InsertSeparator(int currentIndex)
+        {
+            var sepIndex = Parameters.IndexOf("sep");
+            if (sepIndex == -1)
+                return;
+
+            Context.Parts.Insert(currentIndex,
+                new LiteralTemplateSection(Context[Parameters[sepIndex + 1]].ToString(), Context));
+        }
+
+
+        public void Setup(object value)
+        {
+            if (!(value is string) && !(value is ITemplateSection))
+                return;
+            if (IsInserted(value))
+                return;
+
+            _insertedValue = value;
+        }
+    }
+}

mROA.CodegenTools/LinkTemplateSection.cs

@@ -0,0 +1,39 @@
+namespace mROA.CodegenTools
+{
+    public class LinkTemplateSection : ITemplateSection, IBaking
+    {
+        public LinkTemplateSection(string linkedTag, TemplateDocument context)
+        {
+            LinkedTag = linkedTag;
+            Context = context;
+        }
+
+        public string LinkedTag { get; }
+
+        public string Bake()
+        {
+            return Context[LinkedTag]?.ToString();
+        }
+
+        public TemplateDocument Context { get; set; }
+
+        public int TargetLength
+        {
+            get
+            {
+                var attached = Context[LinkedTag];
+                return attached?.TargetLength ?? 0;
+            }
+        }
+
+        public object Clone()
+        {
+            return new LinkTemplateSection(LinkedTag, Context);
+        }
+
+        public override string ToString()
+        {
+            return $"{nameof(LinkedTag)}: {LinkedTag}";
+        }
+    }
+}

mROA.CodegenTools/LiteralTemplateSection.cs

@@ -0,0 +1,31 @@
+namespace mROA.CodegenTools
+{
+    public class LiteralTemplateSection : ITemplateSection, IBaking
+    {
+        private readonly string _internalText;
+
+        public LiteralTemplateSection(string internalText, TemplateDocument context)
+        {
+            _internalText = internalText;
+            Context = context;
+        }
+
+        public string Bake()
+        {
+            return ToString();
+        }
+
+        public TemplateDocument Context { get; set; }
+        public int TargetLength => _internalText.Length;
+
+        public object Clone()
+        {
+            return new LiteralTemplateSection(_internalText, Context);
+        }
+
+        public override string ToString()
+        {
+            return _internalText;
+        }
+    }
+}

mROA.CodegenTools/ProgrammableTextSection.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace mROA.CodegenTools
+{
+    public class ProgrammableTextSection : ITemplateSection, IBaking
+    {
+        private readonly Func<object, string> _bakeFunc;
+
+        public ProgrammableTextSection(Func<object, string> bakeFunc, TemplateDocument context)
+        {
+            _bakeFunc = bakeFunc;
+            Context = context;
+        }
+
+
+        public string Bake()
+        {
+            return _bakeFunc(Context.AdditionalContext);
+        }
+
+        public TemplateDocument Context { get; set; }
+        public int TargetLength => 0;
+
+        public object Clone()
+        {
+            return new ProgrammableTextSection(_bakeFunc, Context);
+        }
+    }
+}

mROA.CodegenTools/Reading/DefineSectionReader.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace mROA.CodegenTools.Reading
+{
+    public class DefineSectionReader : LeadingTextSectionReader
+    {
+        public DefineSectionReader() : base("<!D")
+        {
+        }
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var tagEnd = TemplateText.IndexOf(">", index, StringComparison.Ordinal);
+            var sectionName = GetTagValue(index, tagEnd);
+            tagEnd += 1;
+            var endIndex = TemplateText.IndexOf("<!D>", tagEnd, StringComparison.Ordinal);
+            var storedText = TemplateText.Substring(tagEnd, endIndex - tagEnd);
+            index = endIndex + 4;
+            PassCaretToCloseSymbol();
+            PassCaretToCloseSymbol();
+            return new DefineTemplateSection(storedText, sectionName, document);
+        }
+    }
+}

mROA.CodegenTools/Reading/ISectionReader.cs

@@ -0,0 +1,9 @@
+namespace mROA.CodegenTools.Reading
+{
+    public interface ISectionReader
+    {
+        string TemplateText { get; set; }
+        int GetNextSectionIndex(int currentIndex);
+        ITemplateSection ExtractSection(ref int index, TemplateDocument document);
+    }
+}

mROA.CodegenTools/Reading/InnerTemplateSectionReader.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace mROA.CodegenTools.Reading
+{
+    public class InnerTemplateSectionReader : LeadingTextSectionReader
+    {
+        public InnerTemplateSectionReader()
+            : base("<!T")
+        {
+        }
+
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var end = FindEnd(index + 4);
+            var from = index;
+            index = PassCaretToCloseSymbol();
+            var to = index - 1;
+
+            var tagName = GetTagValue(from, to);
+
+            var innerDocText = TemplateText.Substring(index, end - index);
+            var innerDoc = TemplateReader.Parse(innerDocText);
+            _currentCaretPosition = end + 4;
+            index = _currentCaretPosition;
+            return new InnerTemplateSection(tagName, innerDoc, document);
+        }
+
+        private int FindEnd(int start)
+        {
+            var endSymbol = TemplateText.IndexOf("<!T>", start, StringComparison.Ordinal);
+            var innerStartSymbol = TemplateText.IndexOf("<!T ", start, StringComparison.Ordinal);
+            if (endSymbol < innerStartSymbol || innerStartSymbol == -1)
+                return endSymbol;
+
+            return FindEnd(endSymbol + 4);
+        }
+    }
+}

mROA.CodegenTools/Reading/InsertSectionReader.cs

@@ -0,0 +1,24 @@
+using System.Linq;
+
+namespace mROA.CodegenTools.Reading
+{
+    public class InsertSectionReader : LeadingTextSectionReader
+    {
+        public InsertSectionReader() : base("<!I")
+        {
+        }
+
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var from = index;
+            index = PassCaretToCloseSymbol();
+            var to = index - 1;
+
+            var tagText = GetTagValue(from, to);
+            var parts = tagText.Split(' ');
+
+            return new InsertTemplateSection(parts[0], document, parts.Skip(1).ToArray());
+        }
+    }
+}

mROA.CodegenTools/Reading/LeadingTextSectionReader.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace mROA.CodegenTools.Reading
+{
+    public abstract class LeadingTextSectionReader : ISectionReader
+    {
+        private readonly string _tagLeading;
+        protected int _currentCaretPosition;
+
+        protected LeadingTextSectionReader(string tagLeading)
+        {
+            _tagLeading = tagLeading + " ";
+        }
+
+        public string TemplateText { get; set; }
+
+        public int GetNextSectionIndex(int currentIndex)
+        {
+            _currentCaretPosition = Math.Max(currentIndex, _currentCaretPosition);
+            var index = TemplateText.IndexOf(_tagLeading, _currentCaretPosition, StringComparison.Ordinal);
+            _currentCaretPosition = index;
+            return index;
+        }
+
+        public abstract ITemplateSection ExtractSection(ref int index, TemplateDocument document);
+
+        protected int PassCaretToCloseSymbol()
+        {
+            _currentCaretPosition = TemplateText.IndexOf(">", _currentCaretPosition, StringComparison.Ordinal) + 1;
+            return _currentCaretPosition;
+        }
+
+        protected string GetTagValue(int from, int to)
+        {
+            var realStart = from + 4;
+            var span = TemplateText.AsSpan();
+            var slice = span.Slice(realStart, to - realStart);
+            return new string(slice.ToArray());
+        }
+    }
+}

mROA.CodegenTools/Reading/LinkSectionReader.cs

@@ -0,0 +1,20 @@
+namespace mROA.CodegenTools.Reading
+{
+    public class LinkSectionReader : LeadingTextSectionReader
+    {
+        public LinkSectionReader() : base("<!L")
+        {
+        }
+
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var from = index;
+            index = PassCaretToCloseSymbol();
+            var to = index - 1;
+
+            var tagText = GetTagValue(from, to);
+            return new LinkTemplateSection(tagText, document);
+        }
+    }
+}

mROA.CodegenTools/Reading/TemplateReader.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace mROA.CodegenTools.Reading
+{
+    public static class TemplateReader
+    {
+        private static readonly List<Type> ReaderTypes = new()
+        {
+            typeof(DefineSectionReader),
+            typeof(InsertSectionReader),
+            typeof(LinkSectionReader),
+            typeof(InnerTemplateSectionReader)
+        };
+
+        public static TemplateDocument Parse(string templateText)
+        {
+            var currentIndex = 0;
+            var activeReaders = new List<ISectionReader>();
+
+            foreach (var readerType in ReaderTypes)
+            {
+                var reader = Activator.CreateInstance(readerType) as ISectionReader;
+                reader.TemplateText = templateText;
+                activeReaders.Add(reader);
+            }
+
+            var doc = new TemplateDocument();
+
+            while (currentIndex < templateText.Length)
+            {
+                List<(ISectionReader reader, int index)> indices = activeReaders
+                    .Select(i => ((ISectionReader Readers, int index))(i, i.GetNextSectionIndex(currentIndex)))
+                    .Where(i => i.index > -1).ToList();
+                var minIndex = templateText.Length;
+                ISectionReader minReader = null;
+                if (indices.Count != 0)
+                {
+                    minIndex = indices.Min(i => i.index);
+                    minReader = indices.FirstOrDefault(i => i.index == minIndex).reader;
+
+                    if (indices.Count != activeReaders.Count) activeReaders = indices.Select(i => i.reader).ToList();
+                }
+
+
+                if (currentIndex != minIndex)
+                {
+                    var literalText = templateText.Substring(currentIndex, minIndex - currentIndex);
+                    var literal =
+                        new LiteralTemplateSection(literalText, doc);
+                    doc.Parts.Add(literal);
+                    currentIndex = minIndex;
+                }
+
+                if (indices.Count != 0)
+                {
+                    var section = minReader.ExtractSection(ref currentIndex, doc);
+                    doc.Parts.Add(section);
+                }
+            }
+
+            return doc;
+        }
+
+        public static TemplateDocument FromEmbeddedResource(string resourceName)
+        {
+            return FromEmbeddedResource(resourceName, Assembly.GetCallingAssembly());
+        }
+
+        public static TemplateDocument FromEmbeddedResource(string resourceName, Assembly assembly)
+        {
+            var fileName = assembly.GetManifestResourceNames().First(n => n.EndsWith(resourceName));
+            var res = assembly.GetManifestResourceStream(fileName);
+            var reader = new StreamReader(res);
+            var templateText = reader.ReadToEnd();
+            return Parse(templateText);
+        }
+    }
+}

mROA.CodegenTools/TemplateDocument.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace mROA.CodegenTools
+{
+    public class TemplateDocument : ICloneable
+    {
+        public List<ITemplateSection> Parts { get; set; } = new();
+        public object AdditionalContext { get; set; }
+        public ITagged? this[string tag] => Parts.OfType<ITagged>().FirstOrDefault(i => i.Tag == tag);
+
+        public object Clone()
+        {
+            var cloneDoc = new TemplateDocument
+            {
+                AdditionalContext = AdditionalContext is ICloneable c ? c.Clone() : AdditionalContext
+            };
+
+            cloneDoc.Parts = Parts.Select(i =>
+            {
+                var clone = i.Clone() as ITemplateSection;
+                clone.Context = cloneDoc;
+                return clone;
+            }).ToList();
+
+            return cloneDoc;
+        }
+
+        public void Insert(string tag, object value)
+        {
+            var selectedPart = this[tag];
+            if (selectedPart is InsertTemplateSection itp) itp.Setup(value);
+        }
+
+        public string Compile()
+        {
+            var approximatelyLength = Parts.Sum(i => i.TargetLength);
+            var stringBuilder = new StringBuilder(approximatelyLength);
+
+            foreach (var part in Parts.OfType<IBaking>())
+            {
+                var baked = part.Bake();
+                stringBuilder.Append(baked);
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public void AddDefine(string tag, string text)
+        {
+            Parts.Add(new DefineTemplateSection(text, tag, this));
+        }
+
+        public void AddDefine(string tag, object value)
+        {
+            AddDefine(tag, value.ToString());
+        }
+    }
+}

mROA.CodegenTools/mROA.CodegenTools.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.1</TargetFramework>
+        <Nullable>enable</Nullable>
+        <LangVersion>9</LangVersion>
+    </PropertyGroup>
+
+</Project>

mROA.sln

@@ -23,6 +23,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "mROA.Cbor", "mROA.Cbor\mROA
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "TotalDemo", "TotalDemo", "{FC4FA752-10A7-4D78-A7C2-9BCD8A81FB5E}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "mROA.CodegenTools", "mROA.CodegenTools\mROA.CodegenTools.csproj", "{FFB8DFAE-17F0-4335-8F17-187B3619E8F2}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -61,6 +63,10 @@ Global
 		{6211E4EA-13FD-4EB1-8E6A-C0173DD0784A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6211E4EA-13FD-4EB1-8E6A-C0173DD0784A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6211E4EA-13FD-4EB1-8E6A-C0173DD0784A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FFB8DFAE-17F0-4335-8F17-187B3619E8F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FFB8DFAE-17F0-4335-8F17-187B3619E8F2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FFB8DFAE-17F0-4335-8F17-187B3619E8F2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FFB8DFAE-17F0-4335-8F17-187B3619E8F2}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

mROA/Abstract/IChannelInteractionModule.cs

@@ -17,5 +17,6 @@ namespace mROA.Abstract
         Task PostMessageUntrustedAsync(NetworkMessageHeader messageHeader);
         event Action<int> OnDisconnected;
         Task Restart(bool sendRecovery);
+        void PassReconnection();
     }
 }

mROA/Implementation/ChannelInteractionModule.cs

@@ -128,7 +128,11 @@ namespace mROA.Implementation
                 await _trustedWriter.WriteAsync(new NetworkMessageHeader());
             }
 
+            PassReconnection();
+        }
 
+        public void PassReconnection()
+        {
             _reconnection.TrySetResult(Stream.Null);
             _isConnected = true;
             _reconnection = new TaskCompletionSource<Stream>();

mROA/mROA.csproj

@@ -4,7 +4,7 @@
         <TargetFramework>netstandard2.1</TargetFramework>
         <Nullable>enable</Nullable>
         <Title>mROA</Title>
-        <Version>2.0.5</Version>
+        <Version>2.0.6</Version>
         <Authors>YaslePoy</Authors>
         <Description>Fast and easy RPC with contex</Description>
         <RepositoryUrl>https://github.com/YaslePoy/mROA</RepositoryUrl>