diff --git a/.gitignore b/.gitignore index 1f39135..4f734c3 100644 --- a/.gitignore +++ b/.gitignore @@ -336,4 +336,3 @@ ASALocalRun/ # Capnp code behind .capnp.cs /globalPackages -*.cs diff --git a/CapnpC.CSharp.MsBuild.Generation/AssemblyAttributes.cs b/CapnpC.CSharp.MsBuild.Generation/AssemblyAttributes.cs new file mode 100644 index 0000000..ff364dc --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/AssemblyAttributes.cs @@ -0,0 +1,4 @@ + +using System.Runtime.CompilerServices; +using System.Security; + diff --git a/CapnpC.CSharp.MsBuild.Generation/CapnpCodeBehindGenerator.cs b/CapnpC.CSharp.MsBuild.Generation/CapnpCodeBehindGenerator.cs new file mode 100644 index 0000000..6bc73be --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/CapnpCodeBehindGenerator.cs @@ -0,0 +1,99 @@ +using CapnpC.CSharp.Generator; +using System; +using System.Collections.Generic; +using System.IO; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public class CapnpCodeBehindGenerator : IDisposable + { + + public void InitializeProject(string projectPath) + { + } + + + public CsFileGeneratorResult GenerateCodeBehindFile(CapnpGenJob job) + { + string capnpFile = job.CapnpPath; + + // Works around a weird capnp.exe behavior: When the input file is empty, it will spit out an exception dump + // instead of a parse error. But the parse error is nice because it contains a generated ID. We want the parse error! + // Workaround: Generate a temporary file that contains a single line break (such that it is not empty...) + try + { + if (File.Exists(capnpFile) && new FileInfo(capnpFile).Length == 0) + { + string tempFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".capnp"); + + File.WriteAllText(tempFile, Environment.NewLine); + try + { + var jobCopy = new CapnpGenJob() + { + CapnpPath = tempFile, + WorkingDirectory = job.WorkingDirectory + }; + + jobCopy.AdditionalArguments.AddRange(job.AdditionalArguments); + + return GenerateCodeBehindFile(jobCopy); + } + finally + { + File.Delete(tempFile); + } + } + } + catch + { + } + + var args = new List(); + args.AddRange(job.AdditionalArguments); + args.Add(capnpFile); + + var result = CapnpCompilation.InvokeCapnpAndGenerate(args, job.WorkingDirectory); + + if (result.IsSuccess) + { + if (result.GeneratedFiles.Count == 1) + { + return new CsFileGeneratorResult( + result.GeneratedFiles[0], + capnpFile + ".cs", + result.Messages); + } + else + { + return new CsFileGeneratorResult( + "Code generation produced more than one file. This is not supported.", + result.Messages); + } + } + else + { + switch (result.ErrorCategory) + { + case CapnpProcessFailure.NotFound: + return new CsFileGeneratorResult("Unable to find capnp.exe - please install capnproto on your system first."); + + case CapnpProcessFailure.BadInput: + return new CsFileGeneratorResult("Invalid schema", result.Messages); + + case CapnpProcessFailure.BadOutput: + return new CsFileGeneratorResult( + "Internal error: capnp.exe produced a binary code generation request which was not understood by the backend", + result.Messages); + + default: + throw new NotSupportedException("Invalid error category"); + } + } + } + + public void Dispose() + { + } + } +} \ No newline at end of file diff --git a/CapnpC.CSharp.MsBuild.Generation/CapnpFileCodeBehindGenerator.cs b/CapnpC.CSharp.MsBuild.Generation/CapnpFileCodeBehindGenerator.cs new file mode 100644 index 0000000..26af336 --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/CapnpFileCodeBehindGenerator.cs @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Microsoft.Build.Framework; +using Microsoft.Build.Utilities; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public class CapnpFileCodeBehindGenerator : ICapnpcCsharpGenerator + { + public CapnpFileCodeBehindGenerator(TaskLoggingHelper log) + { + Log = log ?? throw new ArgumentNullException(nameof(log)); + } + + public TaskLoggingHelper Log { get; } + + public IEnumerable GenerateFilesForProject( + string projectPath, + List capnpFiles, + string projectFolder) + { + using (var capnpCodeBehindGenerator = new CapnpCodeBehindGenerator()) + { + capnpCodeBehindGenerator.InitializeProject(projectPath); + + var codeBehindWriter = new CodeBehindWriter(null); + + if (capnpFiles == null) + { + yield break; + } + + foreach (var genJob in capnpFiles) + { + Log.LogMessage(MessageImportance.Normal, "Generate {0}, working dir = {1}, options = {2}", + genJob.CapnpPath, + genJob.WorkingDirectory, + string.Join(" ", genJob.AdditionalArguments)); + + var generatorResult = capnpCodeBehindGenerator.GenerateCodeBehindFile(genJob); + + if (!generatorResult.Success) + { + if (!string.IsNullOrEmpty(generatorResult.Error)) + { + Log.LogError("{0}", generatorResult.Error); + } + + if (generatorResult.Messages != null) + { + foreach (var message in generatorResult.Messages) + { + if (message.IsParseSuccess) + { + Log.LogError( + subcategory: null, + errorCode: null, + helpKeyword: null, + file: genJob.CapnpPath, + lineNumber: message.Line, + columnNumber: message.Column, + endLineNumber: message.Line, + endColumnNumber: message.EndColumn == 0 ? message.Column : message.EndColumn, + "{0}", + message.MessageText); + } + else + { + Log.LogError("{0}", message.FullMessage); + } + } + } + + continue; + } + + var resultedFile = codeBehindWriter.WriteCodeBehindFile(generatorResult.Filename, generatorResult); + + yield return FileSystemHelper.GetRelativePath(resultedFile, projectFolder); + } + } + + } + } +} diff --git a/CapnpC.CSharp.MsBuild.Generation/CapnpGenJob.cs b/CapnpC.CSharp.MsBuild.Generation/CapnpGenJob.cs new file mode 100644 index 0000000..0ac6201 --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/CapnpGenJob.cs @@ -0,0 +1,11 @@ +using System.Collections.Generic; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public class CapnpGenJob + { + public string CapnpPath { get; set; } + public string WorkingDirectory { get; set; } + public List AdditionalArguments { get; } = new List(); + } +} \ No newline at end of file diff --git a/CapnpC.CSharp.MsBuild.Generation/CodeBehindWriter.cs b/CapnpC.CSharp.MsBuild.Generation/CodeBehindWriter.cs new file mode 100644 index 0000000..3ff276b --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/CodeBehindWriter.cs @@ -0,0 +1,38 @@ +using System; +using System.IO; +using Microsoft.Build.Utilities; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public class CodeBehindWriter + { + public CodeBehindWriter(TaskLoggingHelper log) + { + Log = log; + } + + public TaskLoggingHelper Log { get; } + + public string WriteCodeBehindFile(string outputPath, CsFileGeneratorResult testFileGeneratorResult) + { + string directoryPath = Path.GetDirectoryName(outputPath) ?? throw new InvalidOperationException(); + Log?.LogWithNameTag(Log.LogMessage, directoryPath); + + Log?.LogWithNameTag(Log.LogMessage, $"Writing data to {outputPath}; path = {directoryPath}; generatedFilename = {testFileGeneratorResult.Filename}"); + + if (File.Exists(outputPath)) + { + if (!FileSystemHelper.FileCompareContent(outputPath, testFileGeneratorResult.GeneratedCode)) + { + File.WriteAllText(outputPath, testFileGeneratorResult.GeneratedCode); + } + } + else + { + File.WriteAllText(outputPath, testFileGeneratorResult.GeneratedCode); + } + + return outputPath; + } + } +} diff --git a/CapnpC.CSharp.MsBuild.Generation/CsFileGeneratorResult.cs b/CapnpC.CSharp.MsBuild.Generation/CsFileGeneratorResult.cs new file mode 100644 index 0000000..75961ac --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/CsFileGeneratorResult.cs @@ -0,0 +1,51 @@ +using CapnpC.CSharp.Generator; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public class CsFileGeneratorResult + { + public CsFileGeneratorResult(FileGenerationResult generatorResult, string fileName, IReadOnlyList messages) + { + if (generatorResult == null) + { + throw new ArgumentNullException(nameof(generatorResult)); + } + + Filename = fileName ?? throw new ArgumentNullException(nameof(fileName)); + + Error = generatorResult.Exception?.Message; + GeneratedCode = generatorResult.GeneratedContent; + Messages = messages; + } + + public CsFileGeneratorResult(string error) + { + Error = error; + } + + public CsFileGeneratorResult(string error, IReadOnlyList messages) + { + Error = error; + Messages = messages; + } + + /// + /// The error, if any. + /// + public string Error { get; } + + /// + /// The generated code. + /// + public string GeneratedCode { get; } + + public IReadOnlyList Messages { get; } + + public bool Success => Error == null; + + public string Filename { get; } + } +} \ No newline at end of file diff --git a/CapnpC.CSharp.MsBuild.Generation/FileSystemHelper.cs b/CapnpC.CSharp.MsBuild.Generation/FileSystemHelper.cs new file mode 100644 index 0000000..d538531 --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/FileSystemHelper.cs @@ -0,0 +1,112 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Text; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public static class FileSystemHelper + { + public static void CopyFileToFolder(string filePath, string folderName) + { + File.Copy(filePath, Path.Combine(folderName, Path.GetFileName(filePath))); + } + + public static string GetRelativePath(string path, string basePath) + { + path = Path.GetFullPath(path); + basePath = Path.GetFullPath(basePath); + if (String.Equals(path, basePath, StringComparison.OrdinalIgnoreCase)) + return "."; // the "this folder" + + if (path.StartsWith(basePath + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)) + return path.Substring(basePath.Length + 1); + + //handle different drives + string pathRoot = Path.GetPathRoot(path); + if (!String.Equals(pathRoot, Path.GetPathRoot(basePath), StringComparison.OrdinalIgnoreCase)) + return path; + + //handle ".." pathes + string[] pathParts = path.Substring(pathRoot.Length).Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); + string[] basePathParts = basePath.Substring(pathRoot.Length).Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); + + int commonFolderCount = 0; + while (commonFolderCount < pathParts.Length && commonFolderCount < basePathParts.Length && + String.Equals(pathParts[commonFolderCount], basePathParts[commonFolderCount], StringComparison.OrdinalIgnoreCase)) + commonFolderCount++; + + StringBuilder result = new StringBuilder(); + for (int i = 0; i < basePathParts.Length - commonFolderCount; i++) + { + result.Append(".."); + result.Append(Path.DirectorySeparatorChar); + } + + if (pathParts.Length - commonFolderCount == 0) + return result.ToString().TrimEnd(Path.DirectorySeparatorChar); + + result.Append(String.Join(Path.DirectorySeparatorChar.ToString(), pathParts, commonFolderCount, pathParts.Length - commonFolderCount)); + return result.ToString(); + } + + // This method accepts two strings the represent two files to + // compare. A return value of true indicates that the contents of the files + // are the same. A return value of any other value indicates that the + // files are not the same. + public static bool FileCompare(string filePath1, string filePath2) + { + int file1byte; + int file2byte; + + // Determine if the same file was referenced two times. + if (String.Equals(filePath1, filePath2, StringComparison.CurrentCultureIgnoreCase)) + { + // Return true to indicate that the files are the same. + return true; + } + + // Open the two files. + using (FileStream fs1 = new FileStream(filePath1, FileMode.Open, FileAccess.Read)) + { + using (FileStream fs2 = new FileStream(filePath2, FileMode.Open, FileAccess.Read)) + { + // Check the file sizes. If they are not the same, the files + // are not the same. + if (fs1.Length != fs2.Length) + { + // Return false to indicate files are different + return false; + } + + // Read and compare a byte from each file until either a + // non-matching set of bytes is found or until the end of + // file1 is reached. + do + { + // Read one byte from each file. + file1byte = fs1.ReadByte(); + file2byte = fs2.ReadByte(); + } while ((file1byte == file2byte) && (file1byte != -1)); + } + } + // Return the success of the comparison. "file1byte" is + // equal to "file2byte" at this point only if the files are + // the same. + return ((file1byte - file2byte) == 0); + } + + // This method accepts two strings the represent two files to + // compare. A return value of true indicates that the contents of the files + // are the same. A return value of any other value indicates that the + // files are not the same. + public static bool FileCompareContent(string filePath1, string fileContent) + { + var currentFileContent = File.ReadAllText(filePath1); + + return string.CompareOrdinal(currentFileContent, fileContent) == 0; + + } + } +} diff --git a/CapnpC.CSharp.MsBuild.Generation/GenerateCapnpFileCodeBehindTask.cs b/CapnpC.CSharp.MsBuild.Generation/GenerateCapnpFileCodeBehindTask.cs new file mode 100644 index 0000000..459af9b --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/GenerateCapnpFileCodeBehindTask.cs @@ -0,0 +1,136 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Resources; +using Microsoft.Build.Framework; +using Microsoft.Build.Utilities; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public class GenerateCapnpFileCodeBehindTask : Task + { + public GenerateCapnpFileCodeBehindTask() + { + CodeBehindGenerator = new CapnpFileCodeBehindGenerator(Log); + } + + public ICapnpcCsharpGenerator CodeBehindGenerator { get; set; } + + [Required] + public string ProjectPath { get; set; } + + public string ProjectFolder => Path.GetDirectoryName(ProjectPath); + + public ITaskItem[] CapnpFiles { get; set; } + + [Output] + public ITaskItem[] GeneratedFiles { get; private set; } + + static CapnpGenJob ToGenJob(ITaskItem item) + { + var job = new CapnpGenJob() + { + CapnpPath = item.GetMetadata("FullPath"), + WorkingDirectory = item.GetMetadata("WorkingDirectory") + }; + + string importPaths = item.GetMetadata("ImportPaths"); + + if (!string.IsNullOrWhiteSpace(importPaths)) + { + job.AdditionalArguments.AddRange(importPaths.Split(new char[] { ';' }, + StringSplitOptions.RemoveEmptyEntries).Select(p => $"-I\"{p.TrimEnd('\\')}\"")); + } + + string sourcePrefix = item.GetMetadata("SourcePrefix"); + + if (!string.IsNullOrWhiteSpace(sourcePrefix)) + { + job.AdditionalArguments.Add(sourcePrefix); + } + + + string verbose = item.GetMetadata("Verbose"); + + if ("true".Equals(verbose, StringComparison.OrdinalIgnoreCase)) + { + job.AdditionalArguments.Add("--verbose"); + } + + return job; + } + + public override bool Execute() + { + try + { + try + { + var currentProcess = Process.GetCurrentProcess(); + + Log.LogWithNameTag(Log.LogMessage, $"process: {currentProcess.ProcessName}, pid: {currentProcess.Id}, CD: {Environment.CurrentDirectory}"); + + foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) + { + Log.LogWithNameTag(Log.LogMessage, " " + assembly.FullName); + } + } + catch (Exception e) + { + Log.LogWithNameTag(Log.LogMessage, $"Error when dumping process info: {e}"); + } + + AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve; + + var generator = CodeBehindGenerator ?? new CapnpFileCodeBehindGenerator(Log); + + Log.LogWithNameTag(Log.LogMessage, "Starting GenerateCapnpFileCodeBehind"); + + var capnpFiles = CapnpFiles?.Select(ToGenJob).ToList() ?? new List(); + + var generatedFiles = generator.GenerateFilesForProject( + ProjectPath, + capnpFiles, + ProjectFolder); + + GeneratedFiles = generatedFiles.Select(file => new TaskItem { ItemSpec = file }).ToArray(); + + return !Log.HasLoggedErrors; + } + catch (Exception e) + { + if (e.InnerException != null) + { + if (e.InnerException is FileLoadException fle) + { + Log?.LogWithNameTag(Log.LogError, $"FileLoadException Filename: {fle.FileName}"); + Log?.LogWithNameTag(Log.LogError, $"FileLoadException FusionLog: {fle.FusionLog}"); + Log?.LogWithNameTag(Log.LogError, $"FileLoadException Message: {fle.Message}"); + } + + Log?.LogWithNameTag(Log.LogError, e.InnerException.ToString()); + } + + Log?.LogWithNameTag(Log.LogError, e.ToString()); + return false; + } + finally + { + AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve; + } + } + + private System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) + { + Log.LogWithNameTag(Log.LogMessage, args.Name); + + + return null; + } + + } + + +} \ No newline at end of file diff --git a/CapnpC.CSharp.MsBuild.Generation/Helper/LogExtensions.cs b/CapnpC.CSharp.MsBuild.Generation/Helper/LogExtensions.cs new file mode 100644 index 0000000..3203bea --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/Helper/LogExtensions.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Microsoft.Build.Utilities; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public static class LogExtensions + { + public static void LogWithNameTag( + this TaskLoggingHelper loggingHelper, + Action loggingMethod, + string message, + params object[] messageArgs) + { + string fullMessage = $"[Cap'n Proto] {message}"; + loggingMethod?.Invoke(fullMessage, messageArgs); + } + } +} diff --git a/CapnpC.CSharp.MsBuild.Generation/ICapnpCsharpGenerator.cs b/CapnpC.CSharp.MsBuild.Generation/ICapnpCsharpGenerator.cs new file mode 100644 index 0000000..965b0ce --- /dev/null +++ b/CapnpC.CSharp.MsBuild.Generation/ICapnpCsharpGenerator.cs @@ -0,0 +1,9 @@ +using System.Collections.Generic; + +namespace CapnpC.CSharp.MsBuild.Generation +{ + public interface ICapnpcCsharpGenerator + { + IEnumerable GenerateFilesForProject(string projectPath, List jobs, string projectFolder); + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/AddressBook.capnp.cs b/MsBuildGenerationTest/AddressBook.capnp.cs new file mode 100644 index 0000000..ebffe97 --- /dev/null +++ b/MsBuildGenerationTest/AddressBook.capnp.cs @@ -0,0 +1,412 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace CapnpGen +{ + public class Person : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + Name = reader.Name; + Email = reader.Email; + Phones = reader.Phones.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + Employment = CapnpSerializable.Create(reader.Employment); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + writer.Name = Name; + writer.Email = Email; + writer.Phones.Init(Phones, (_s1, _v1) => _v1?.serialize(_s1)); + Employment?.serialize(writer.Employment); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Id + { + get; + set; + } + + public string Name + { + get; + set; + } + + public string Email + { + get; + set; + } + + public IReadOnlyList Phones + { + get; + set; + } + + public CapnpGen.Person.@employment Employment + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint Id => ctx.ReadDataUInt(0UL, 0U); + public string Name => ctx.ReadText(0, ""); + public string Email => ctx.ReadText(1, ""); + public IReadOnlyList Phones => ctx.ReadList(2).Cast(CapnpGen.Person.PhoneNumber.READER.create); + public @employment.READER Employment => new @employment.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 4); + } + + public uint Id + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string Email + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + + public ListOfStructsSerializer Phones + { + get => BuildPointer>(2); + set => Link(2, value); + } + + public @employment.WRITER Employment + { + get => Rewrap<@employment.WRITER>(); + } + } + + public class @employment : ICapnpSerializable + { + public enum WHICH : ushort + { + Unemployed = 0, + Employer = 1, + School = 2, + SelfEmployed = 3, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Unemployed: + which = reader.which; + break; + case WHICH.Employer: + Employer = reader.Employer; + break; + case WHICH.School: + School = reader.School; + break; + case WHICH.SelfEmployed: + which = reader.which; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Unemployed: + break; + case WHICH.Employer: + _content = null; + break; + case WHICH.School: + _content = null; + break; + case WHICH.SelfEmployed: + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Unemployed: + break; + case WHICH.Employer: + writer.Employer = Employer; + break; + case WHICH.School: + writer.School = School; + break; + case WHICH.SelfEmployed: + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Employer + { + get => _which == WHICH.Employer ? (string)_content : null; + set + { + _which = WHICH.Employer; + _content = value; + } + } + + public string School + { + get => _which == WHICH.School ? (string)_content : null; + set + { + _which = WHICH.School; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public string Employer => which == WHICH.Employer ? ctx.ReadText(3, "") : default; + public string School => which == WHICH.School ? ctx.ReadText(3, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public string Employer + { + get => which == WHICH.Employer ? this.ReadText(3, "") : default; + set => this.WriteText(3, value, ""); + } + + public string School + { + get => which == WHICH.School ? this.ReadText(3, "") : default; + set => this.WriteText(3, value, ""); + } + } + } + + public class PhoneNumber : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Number = reader.Number; + TheType = reader.TheType; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Number = Number; + writer.TheType = TheType; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Number + { + get; + set; + } + + public CapnpGen.Person.PhoneNumber.Type TheType + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Number => ctx.ReadText(0, ""); + public CapnpGen.Person.PhoneNumber.Type TheType => (CapnpGen.Person.PhoneNumber.Type)ctx.ReadDataUShort(0UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public string Number + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public CapnpGen.Person.PhoneNumber.Type TheType + { + get => (CapnpGen.Person.PhoneNumber.Type)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + } + + public enum Type : ushort + { + mobile, + home, + work + } + } + } + + public class AddressBook : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + People = reader.People.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.People.Init(People, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList People + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList People => ctx.ReadList(0).Cast(CapnpGen.Person.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public ListOfStructsSerializer People + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/Program.cs b/MsBuildGenerationTest/Program.cs new file mode 100644 index 0000000..b07986b --- /dev/null +++ b/MsBuildGenerationTest/Program.cs @@ -0,0 +1,12 @@ +using System; + +namespace MsBuildGenerationTest +{ + class Program + { + static void Main(string[] args) + { + Console.WriteLine("Hello World!"); + } + } +} diff --git a/MsBuildGenerationTest/capnp/c++.capnp.cs b/MsBuildGenerationTest/capnp/c++.capnp.cs new file mode 100644 index 0000000..e43c504 --- /dev/null +++ b/MsBuildGenerationTest/capnp/c++.capnp.cs @@ -0,0 +1,10 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Annotations +{ +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/compat/json-test.capnp.cs b/MsBuildGenerationTest/capnp/compat/json-test.capnp.cs new file mode 100644 index 0000000..c6366e6 --- /dev/null +++ b/MsBuildGenerationTest/capnp/compat/json-test.capnp.cs @@ -0,0 +1,1559 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp +{ + public class TestJsonAnnotations : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + SomeField = reader.SomeField; + AGroup = CapnpSerializable.Create(reader.AGroup); + PrefixedGroup = CapnpSerializable.Create(reader.PrefixedGroup); + AUnion = CapnpSerializable.Create(reader.AUnion); + Dependency = CapnpSerializable.Create(reader.Dependency); + SimpleGroup = CapnpSerializable.Create(reader.SimpleGroup); + Enums = reader.Enums; + InnerJson = CapnpSerializable.Create(reader.InnerJson); + CustomFieldHandler = reader.CustomFieldHandler; + TestBase64 = reader.TestBase64; + TestHex = reader.TestHex; + BUnion = CapnpSerializable.Create(reader.BUnion); + ExternalUnion = CapnpSerializable.Create(reader.ExternalUnion); + UnionWithVoid = CapnpSerializable.Create(reader.UnionWithVoid); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.SomeField = SomeField; + AGroup?.serialize(writer.AGroup); + PrefixedGroup?.serialize(writer.PrefixedGroup); + AUnion?.serialize(writer.AUnion); + Dependency?.serialize(writer.Dependency); + SimpleGroup?.serialize(writer.SimpleGroup); + writer.Enums.Init(Enums); + InnerJson?.serialize(writer.InnerJson); + writer.CustomFieldHandler = CustomFieldHandler; + writer.TestBase64.Init(TestBase64); + writer.TestHex.Init(TestHex); + BUnion?.serialize(writer.BUnion); + ExternalUnion?.serialize(writer.ExternalUnion); + UnionWithVoid?.serialize(writer.UnionWithVoid); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string SomeField + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@aGroup AGroup + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@prefixedGroup PrefixedGroup + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@aUnion AUnion + { + get; + set; + } + + public Capnp.TestJsonAnnotations2 Dependency + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@simpleGroup SimpleGroup + { + get; + set; + } + + public IReadOnlyList Enums + { + get; + set; + } + + public Capnp.Json.Value InnerJson + { + get; + set; + } + + public string CustomFieldHandler + { + get; + set; + } + + public IReadOnlyList TestBase64 + { + get; + set; + } + + public IReadOnlyList TestHex + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@bUnion BUnion + { + get; + set; + } + + public Capnp.TestJsonAnnotations3 ExternalUnion + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@unionWithVoid UnionWithVoid + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string SomeField => ctx.ReadText(0, ""); + public @aGroup.READER AGroup => new @aGroup.READER(ctx); + public @prefixedGroup.READER PrefixedGroup => new @prefixedGroup.READER(ctx); + public @aUnion.READER AUnion => new @aUnion.READER(ctx); + public Capnp.TestJsonAnnotations2.READER Dependency => ctx.ReadStruct(6, Capnp.TestJsonAnnotations2.READER.create); + public @simpleGroup.READER SimpleGroup => new @simpleGroup.READER(ctx); + public IReadOnlyList Enums => ctx.ReadList(8).CastEnums(_0 => (Capnp.TestJsonAnnotatedEnum)_0); + public Capnp.Json.Value.READER InnerJson => ctx.ReadStruct(9, Capnp.Json.Value.READER.create); + public string CustomFieldHandler => ctx.ReadText(10, ""); + public IReadOnlyList TestBase64 => ctx.ReadList(11).CastByte(); + public IReadOnlyList TestHex => ctx.ReadList(12).CastByte(); + public @bUnion.READER BUnion => new @bUnion.READER(ctx); + public Capnp.TestJsonAnnotations3.READER ExternalUnion => ctx.ReadStruct(14, Capnp.TestJsonAnnotations3.READER.create); + public @unionWithVoid.READER UnionWithVoid => new @unionWithVoid.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(4, 16); + } + + public string SomeField + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public @aGroup.WRITER AGroup + { + get => Rewrap<@aGroup.WRITER>(); + } + + public @prefixedGroup.WRITER PrefixedGroup + { + get => Rewrap<@prefixedGroup.WRITER>(); + } + + public @aUnion.WRITER AUnion + { + get => Rewrap<@aUnion.WRITER>(); + } + + public Capnp.TestJsonAnnotations2.WRITER Dependency + { + get => BuildPointer(6); + set => Link(6, value); + } + + public @simpleGroup.WRITER SimpleGroup + { + get => Rewrap<@simpleGroup.WRITER>(); + } + + public ListOfPrimitivesSerializer Enums + { + get => BuildPointer>(8); + set => Link(8, value); + } + + public Capnp.Json.Value.WRITER InnerJson + { + get => BuildPointer(9); + set => Link(9, value); + } + + public string CustomFieldHandler + { + get => this.ReadText(10, ""); + set => this.WriteText(10, value, ""); + } + + public ListOfPrimitivesSerializer TestBase64 + { + get => BuildPointer>(11); + set => Link(11, value); + } + + public ListOfPrimitivesSerializer TestHex + { + get => BuildPointer>(12); + set => Link(12, value); + } + + public @bUnion.WRITER BUnion + { + get => Rewrap<@bUnion.WRITER>(); + } + + public Capnp.TestJsonAnnotations3.WRITER ExternalUnion + { + get => BuildPointer(14); + set => Link(14, value); + } + + public @unionWithVoid.WRITER UnionWithVoid + { + get => Rewrap<@unionWithVoid.WRITER>(); + } + } + + public class @aGroup : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + FlatFoo = reader.FlatFoo; + FlatBar = reader.FlatBar; + FlatBaz = CapnpSerializable.Create(reader.FlatBaz); + DoubleFlat = CapnpSerializable.Create(reader.DoubleFlat); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.FlatFoo = FlatFoo; + writer.FlatBar = FlatBar; + FlatBaz?.serialize(writer.FlatBaz); + DoubleFlat?.serialize(writer.DoubleFlat); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint FlatFoo + { + get; + set; + } + + public string FlatBar + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@aGroup.@flatBaz FlatBaz + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@aGroup.@doubleFlat DoubleFlat + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint FlatFoo => ctx.ReadDataUInt(0UL, 0U); + public string FlatBar => ctx.ReadText(1, ""); + public @flatBaz.READER FlatBaz => new @flatBaz.READER(ctx); + public @doubleFlat.READER DoubleFlat => new @doubleFlat.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public uint FlatFoo + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public string FlatBar + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + + public @flatBaz.WRITER FlatBaz + { + get => Rewrap<@flatBaz.WRITER>(); + } + + public @doubleFlat.WRITER DoubleFlat + { + get => Rewrap<@doubleFlat.WRITER>(); + } + } + + public class @flatBaz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Hello = reader.Hello; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Hello = Hello; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool Hello + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool Hello => ctx.ReadDataBool(32UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public bool Hello + { + get => this.ReadDataBool(32UL, false); + set => this.WriteData(32UL, value, false); + } + } + } + + public class @doubleFlat : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + FlatQux = reader.FlatQux; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.FlatQux = FlatQux; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string FlatQux + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string FlatQux => ctx.ReadText(2, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public string FlatQux + { + get => this.ReadText(2, ""); + set => this.WriteText(2, value, ""); + } + } + } + } + + public class @prefixedGroup : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = reader.Foo; + Bar = reader.Bar; + Baz = CapnpSerializable.Create(reader.Baz); + MorePrefix = CapnpSerializable.Create(reader.MorePrefix); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo = Foo; + writer.Bar = Bar; + Baz?.serialize(writer.Baz); + MorePrefix?.serialize(writer.MorePrefix); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Foo + { + get; + set; + } + + public uint Bar + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@prefixedGroup.@baz Baz + { + get; + set; + } + + public Capnp.TestJsonAnnotations.@prefixedGroup.@morePrefix MorePrefix + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Foo => ctx.ReadText(3, ""); + public uint Bar => ctx.ReadDataUInt(64UL, 0U); + public @baz.READER Baz => new @baz.READER(ctx); + public @morePrefix.READER MorePrefix => new @morePrefix.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public string Foo + { + get => this.ReadText(3, ""); + set => this.WriteText(3, value, ""); + } + + public uint Bar + { + get => this.ReadDataUInt(64UL, 0U); + set => this.WriteData(64UL, value, 0U); + } + + public @baz.WRITER Baz + { + get => Rewrap<@baz.WRITER>(); + } + + public @morePrefix.WRITER MorePrefix + { + get => Rewrap<@morePrefix.WRITER>(); + } + } + + public class @baz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Hello = reader.Hello; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Hello = Hello; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool Hello + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool Hello => ctx.ReadDataBool(33UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public bool Hello + { + get => this.ReadDataBool(33UL, false); + set => this.WriteData(33UL, value, false); + } + } + } + + public class @morePrefix : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Qux = reader.Qux; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Qux = Qux; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Qux + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Qux => ctx.ReadText(4, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public string Qux + { + get => this.ReadText(4, ""); + set => this.WriteText(4, value, ""); + } + } + } + } + + public class @aUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = CapnpSerializable.Create(reader.Foo); + break; + case WHICH.Bar: + Bar = CapnpSerializable.Create(reader.Bar); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = null; + break; + case WHICH.Bar: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + Foo?.serialize(writer.Foo); + break; + case WHICH.Bar: + Bar?.serialize(writer.Bar); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.TestJsonAnnotations.@aUnion.@foo Foo + { + get => _which == WHICH.Foo ? (Capnp.TestJsonAnnotations.@aUnion.@foo)_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public Capnp.TestJsonAnnotations.@aUnion.@bar Bar + { + get => _which == WHICH.Bar ? (Capnp.TestJsonAnnotations.@aUnion.@bar)_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public @foo.READER Foo => which == WHICH.Foo ? new @foo.READER(ctx) : default; + public @bar.READER Bar => which == WHICH.Bar ? new @bar.READER(ctx) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public @foo.WRITER Foo + { + get => which == WHICH.Foo ? Rewrap<@foo.WRITER>() : default; + } + + public @bar.WRITER Bar + { + get => which == WHICH.Bar ? Rewrap<@bar.WRITER>() : default; + } + } + + public class @foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + FooMember = reader.FooMember; + MultiMember = reader.MultiMember; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.FooMember = FooMember; + writer.MultiMember = MultiMember; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string FooMember + { + get; + set; + } + + public uint MultiMember + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string FooMember => ctx.ReadText(5, ""); + public uint MultiMember => ctx.ReadDataUInt(96UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public string FooMember + { + get => this.ReadText(5, ""); + set => this.WriteText(5, value, ""); + } + + public uint MultiMember + { + get => this.ReadDataUInt(96UL, 0U); + set => this.WriteData(96UL, value, 0U); + } + } + } + + public class @bar : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BarMember = reader.BarMember; + MultiMember = reader.MultiMember; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BarMember = BarMember; + writer.MultiMember = MultiMember; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint BarMember + { + get; + set; + } + + public string MultiMember + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint BarMember => ctx.ReadDataUInt(96UL, 0U); + public string MultiMember => ctx.ReadText(5, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public uint BarMember + { + get => this.ReadDataUInt(96UL, 0U); + set => this.WriteData(96UL, value, 0U); + } + + public string MultiMember + { + get => this.ReadText(5, ""); + set => this.WriteText(5, value, ""); + } + } + } + } + + public class @simpleGroup : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Grault = reader.Grault; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Grault = Grault; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Grault + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Grault => ctx.ReadText(7, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public string Grault + { + get => this.ReadText(7, ""); + set => this.WriteText(7, value, ""); + } + } + } + + public class @bUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = reader.Foo; + break; + case WHICH.Bar: + Bar = reader.Bar; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = null; + break; + case WHICH.Bar: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo = Foo; + break; + case WHICH.Bar: + writer.Bar = Bar.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Foo + { + get => _which == WHICH.Foo ? (string)_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public uint? Bar + { + get => _which == WHICH.Bar ? (uint? )_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(128U, (ushort)0); + public string Foo => which == WHICH.Foo ? ctx.ReadText(13, "") : default; + public uint Bar => which == WHICH.Bar ? ctx.ReadDataUInt(160UL, 0U) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(128U, (ushort)0); + set => this.WriteData(128U, (ushort)value, (ushort)0); + } + + public string Foo + { + get => which == WHICH.Foo ? this.ReadText(13, "") : default; + set => this.WriteText(13, value, ""); + } + + public uint Bar + { + get => which == WHICH.Bar ? this.ReadDataUInt(160UL, 0U) : default; + set => this.WriteData(160UL, value, 0U); + } + } + } + + public class @unionWithVoid : ICapnpSerializable + { + public enum WHICH : ushort + { + IntValue = 0, + VoidValue = 1, + TextValue = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.IntValue: + IntValue = reader.IntValue; + break; + case WHICH.VoidValue: + which = reader.which; + break; + case WHICH.TextValue: + TextValue = reader.TextValue; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.IntValue: + _content = 0; + break; + case WHICH.VoidValue: + break; + case WHICH.TextValue: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.IntValue: + writer.IntValue = IntValue.Value; + break; + case WHICH.VoidValue: + break; + case WHICH.TextValue: + writer.TextValue = TextValue; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? IntValue + { + get => _which == WHICH.IntValue ? (uint? )_content : null; + set + { + _which = WHICH.IntValue; + _content = value; + } + } + + public string TextValue + { + get => _which == WHICH.TextValue ? (string)_content : null; + set + { + _which = WHICH.TextValue; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(144U, (ushort)0); + public uint IntValue => which == WHICH.IntValue ? ctx.ReadDataUInt(192UL, 0U) : default; + public string TextValue => which == WHICH.TextValue ? ctx.ReadText(15, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(144U, (ushort)0); + set => this.WriteData(144U, (ushort)value, (ushort)0); + } + + public uint IntValue + { + get => which == WHICH.IntValue ? this.ReadDataUInt(192UL, 0U) : default; + set => this.WriteData(192UL, value, 0U); + } + + public string TextValue + { + get => which == WHICH.TextValue ? this.ReadText(15, "") : default; + set => this.WriteText(15, value, ""); + } + } + } + } + + public class TestJsonAnnotations2 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = reader.Foo; + Cycle = CapnpSerializable.Create(reader.Cycle); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo = Foo; + Cycle?.serialize(writer.Cycle); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Foo + { + get; + set; + } + + public Capnp.TestJsonAnnotations Cycle + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Foo => ctx.ReadText(0, ""); + public Capnp.TestJsonAnnotations.READER Cycle => ctx.ReadStruct(1, Capnp.TestJsonAnnotations.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string Foo + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnp.TestJsonAnnotations.WRITER Cycle + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class TestJsonAnnotations3 : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = reader.Foo; + break; + case WHICH.Bar: + Bar = CapnpSerializable.Create(reader.Bar); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = 0; + break; + case WHICH.Bar: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo = Foo.Value; + break; + case WHICH.Bar: + Bar?.serialize(writer.Bar); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? Foo + { + get => _which == WHICH.Foo ? (uint? )_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public Capnp.TestFlattenedStruct Bar + { + get => _which == WHICH.Bar ? (Capnp.TestFlattenedStruct)_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public uint Foo => which == WHICH.Foo ? ctx.ReadDataUInt(0UL, 0U) : default; + public Capnp.TestFlattenedStruct.READER Bar => which == WHICH.Bar ? ctx.ReadStruct(0, Capnp.TestFlattenedStruct.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public uint Foo + { + get => which == WHICH.Foo ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.TestFlattenedStruct.WRITER Bar + { + get => which == WHICH.Bar ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class TestFlattenedStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Value = reader.Value; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Value = Value; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Value + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Value => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Value + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public enum TestJsonAnnotatedEnum : ushort + { + foo, + bar, + baz, + qux + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/compat/json.capnp.cs b/MsBuildGenerationTest/capnp/compat/json.capnp.cs new file mode 100644 index 0000000..062257f --- /dev/null +++ b/MsBuildGenerationTest/capnp/compat/json.capnp.cs @@ -0,0 +1,536 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Json +{ + public class Value : ICapnpSerializable + { + public enum WHICH : ushort + { + Null = 0, + Boolean = 1, + Number = 2, + String = 3, + Array = 4, + Object = 5, + TheCall = 6, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Null: + which = reader.which; + break; + case WHICH.Boolean: + Boolean = reader.Boolean; + break; + case WHICH.Number: + Number = reader.Number; + break; + case WHICH.String: + String = reader.String; + break; + case WHICH.Array: + Array = reader.Array.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + break; + case WHICH.Object: + Object = reader.Object.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + break; + case WHICH.TheCall: + TheCall = CapnpSerializable.Create(reader.TheCall); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Null: + break; + case WHICH.Boolean: + _content = false; + break; + case WHICH.Number: + _content = 0; + break; + case WHICH.String: + _content = null; + break; + case WHICH.Array: + _content = null; + break; + case WHICH.Object: + _content = null; + break; + case WHICH.TheCall: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Null: + break; + case WHICH.Boolean: + writer.Boolean = Boolean.Value; + break; + case WHICH.Number: + writer.Number = Number.Value; + break; + case WHICH.String: + writer.String = String; + break; + case WHICH.Array: + writer.Array.Init(Array, (_s1, _v1) => _v1?.serialize(_s1)); + break; + case WHICH.Object: + writer.Object.Init(Object, (_s1, _v1) => _v1?.serialize(_s1)); + break; + case WHICH.TheCall: + TheCall?.serialize(writer.TheCall); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? Boolean + { + get => _which == WHICH.Boolean ? (bool? )_content : null; + set + { + _which = WHICH.Boolean; + _content = value; + } + } + + public double? Number + { + get => _which == WHICH.Number ? (double? )_content : null; + set + { + _which = WHICH.Number; + _content = value; + } + } + + public string String + { + get => _which == WHICH.String ? (string)_content : null; + set + { + _which = WHICH.String; + _content = value; + } + } + + public IReadOnlyList Array + { + get => _which == WHICH.Array ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Array; + _content = value; + } + } + + public IReadOnlyList Object + { + get => _which == WHICH.Object ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Object; + _content = value; + } + } + + public Capnp.Json.Value.Call TheCall + { + get => _which == WHICH.TheCall ? (Capnp.Json.Value.Call)_content : null; + set + { + _which = WHICH.TheCall; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public bool Boolean => which == WHICH.Boolean ? ctx.ReadDataBool(16UL, false) : default; + public double Number => which == WHICH.Number ? ctx.ReadDataDouble(64UL, 0) : default; + public string String => which == WHICH.String ? ctx.ReadText(0, "") : default; + public IReadOnlyList Array => which == WHICH.Array ? ctx.ReadList(0).Cast(Capnp.Json.Value.READER.create) : default; + public IReadOnlyList Object => which == WHICH.Object ? ctx.ReadList(0).Cast(Capnp.Json.Value.Field.READER.create) : default; + public Capnp.Json.Value.Call.READER TheCall => which == WHICH.TheCall ? ctx.ReadStruct(0, Capnp.Json.Value.Call.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public bool Boolean + { + get => which == WHICH.Boolean ? this.ReadDataBool(16UL, false) : default; + set => this.WriteData(16UL, value, false); + } + + public double Number + { + get => which == WHICH.Number ? this.ReadDataDouble(64UL, 0) : default; + set => this.WriteData(64UL, value, 0); + } + + public string String + { + get => which == WHICH.String ? this.ReadText(0, "") : default; + set => this.WriteText(0, value, ""); + } + + public ListOfStructsSerializer Array + { + get => which == WHICH.Array ? BuildPointer>(0) : default; + set => Link(0, value); + } + + public ListOfStructsSerializer Object + { + get => which == WHICH.Object ? BuildPointer>(0) : default; + set => Link(0, value); + } + + public Capnp.Json.Value.Call.WRITER TheCall + { + get => which == WHICH.TheCall ? BuildPointer(0) : default; + set => Link(0, value); + } + } + + public class Field : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Name = reader.Name; + Value = CapnpSerializable.Create(reader.Value); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Name = Name; + Value?.serialize(writer.Value); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + get; + set; + } + + public Capnp.Json.Value Value + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Name => ctx.ReadText(0, ""); + public Capnp.Json.Value.READER Value => ctx.ReadStruct(1, Capnp.Json.Value.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnp.Json.Value.WRITER Value + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class Call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Function = reader.Function; + Params = reader.Params.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Function = Function; + writer.Params.Init(Params, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Function + { + get; + set; + } + + public IReadOnlyList Params + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Function => ctx.ReadText(0, ""); + public IReadOnlyList Params => ctx.ReadList(1).Cast(Capnp.Json.Value.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string Function + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ListOfStructsSerializer Params + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + } + + public class FlattenOptions : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Prefix = reader.Prefix; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Prefix = Prefix; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + Prefix = Prefix ?? ""; + } + + public string Prefix + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Prefix => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Prefix + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class DiscriminatorOptions : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Name = reader.Name; + ValueName = reader.ValueName; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Name = Name; + writer.ValueName = ValueName; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + get; + set; + } + + public string ValueName + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Name => ctx.ReadText(0, ""); + public string ValueName => ctx.ReadText(1, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string ValueName + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + } + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/rpc-twoparty.capnp.cs b/MsBuildGenerationTest/capnp/rpc-twoparty.capnp.cs new file mode 100644 index 0000000..4d66331 --- /dev/null +++ b/MsBuildGenerationTest/capnp/rpc-twoparty.capnp.cs @@ -0,0 +1,393 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc.Twoparty +{ + public enum Side : ushort + { + server, + client + } + + public class VatId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Side = reader.Side; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Side = Side; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Rpc.Twoparty.Side Side + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnp.Rpc.Twoparty.Side Side => (Capnp.Rpc.Twoparty.Side)ctx.ReadDataUShort(0UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public Capnp.Rpc.Twoparty.Side Side + { + get => (Capnp.Rpc.Twoparty.Side)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + } + } + + public class ProvisionId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + JoinId = reader.JoinId; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.JoinId = JoinId; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint JoinId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint JoinId => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint JoinId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + + public class RecipientId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class ThirdPartyCapId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class JoinKeyPart : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + JoinId = reader.JoinId; + PartCount = reader.PartCount; + PartNum = reader.PartNum; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.JoinId = JoinId; + writer.PartCount = PartCount; + writer.PartNum = PartNum; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint JoinId + { + get; + set; + } + + public ushort PartCount + { + get; + set; + } + + public ushort PartNum + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint JoinId => ctx.ReadDataUInt(0UL, 0U); + public ushort PartCount => ctx.ReadDataUShort(32UL, (ushort)0); + public ushort PartNum => ctx.ReadDataUShort(48UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint JoinId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public ushort PartCount + { + get => this.ReadDataUShort(32UL, (ushort)0); + set => this.WriteData(32UL, value, (ushort)0); + } + + public ushort PartNum + { + get => this.ReadDataUShort(48UL, (ushort)0); + set => this.WriteData(48UL, value, (ushort)0); + } + } + } + + public class JoinResult : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + JoinId = reader.JoinId; + Succeeded = reader.Succeeded; + Cap = CapnpSerializable.Create(reader.Cap); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.JoinId = JoinId; + writer.Succeeded = Succeeded; + writer.Cap.SetObject(Cap); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint JoinId + { + get; + set; + } + + public bool Succeeded + { + get; + set; + } + + public AnyPointer Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint JoinId => ctx.ReadDataUInt(0UL, 0U); + public bool Succeeded => ctx.ReadDataBool(32UL, false); + public DeserializerState Cap => ctx.StructReadPointer(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint JoinId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public bool Succeeded + { + get => this.ReadDataBool(32UL, false); + set => this.WriteData(32UL, value, false); + } + + public DynamicSerializerState Cap + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/rpc.capnp.cs b/MsBuildGenerationTest/capnp/rpc.capnp.cs new file mode 100644 index 0000000..35b0269 --- /dev/null +++ b/MsBuildGenerationTest/capnp/rpc.capnp.cs @@ -0,0 +1,2641 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Rpc +{ + public class Message : ICapnpSerializable + { + public enum WHICH : ushort + { + Unimplemented = 0, + Abort = 1, + Call = 2, + Return = 3, + Finish = 4, + Resolve = 5, + Release = 6, + ObsoleteSave = 7, + Bootstrap = 8, + ObsoleteDelete = 9, + Provide = 10, + Accept = 11, + Join = 12, + Disembargo = 13, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Unimplemented: + Unimplemented = CapnpSerializable.Create(reader.Unimplemented); + break; + case WHICH.Abort: + Abort = CapnpSerializable.Create(reader.Abort); + break; + case WHICH.Call: + Call = CapnpSerializable.Create(reader.Call); + break; + case WHICH.Return: + Return = CapnpSerializable.Create(reader.Return); + break; + case WHICH.Finish: + Finish = CapnpSerializable.Create(reader.Finish); + break; + case WHICH.Resolve: + Resolve = CapnpSerializable.Create(reader.Resolve); + break; + case WHICH.Release: + Release = CapnpSerializable.Create(reader.Release); + break; + case WHICH.ObsoleteSave: + ObsoleteSave = CapnpSerializable.Create(reader.ObsoleteSave); + break; + case WHICH.Bootstrap: + Bootstrap = CapnpSerializable.Create(reader.Bootstrap); + break; + case WHICH.ObsoleteDelete: + ObsoleteDelete = CapnpSerializable.Create(reader.ObsoleteDelete); + break; + case WHICH.Provide: + Provide = CapnpSerializable.Create(reader.Provide); + break; + case WHICH.Accept: + Accept = CapnpSerializable.Create(reader.Accept); + break; + case WHICH.Join: + Join = CapnpSerializable.Create(reader.Join); + break; + case WHICH.Disembargo: + Disembargo = CapnpSerializable.Create(reader.Disembargo); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Unimplemented: + _content = null; + break; + case WHICH.Abort: + _content = null; + break; + case WHICH.Call: + _content = null; + break; + case WHICH.Return: + _content = null; + break; + case WHICH.Finish: + _content = null; + break; + case WHICH.Resolve: + _content = null; + break; + case WHICH.Release: + _content = null; + break; + case WHICH.ObsoleteSave: + _content = null; + break; + case WHICH.Bootstrap: + _content = null; + break; + case WHICH.ObsoleteDelete: + _content = null; + break; + case WHICH.Provide: + _content = null; + break; + case WHICH.Accept: + _content = null; + break; + case WHICH.Join: + _content = null; + break; + case WHICH.Disembargo: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Unimplemented: + Unimplemented?.serialize(writer.Unimplemented); + break; + case WHICH.Abort: + Abort?.serialize(writer.Abort); + break; + case WHICH.Call: + Call?.serialize(writer.Call); + break; + case WHICH.Return: + Return?.serialize(writer.Return); + break; + case WHICH.Finish: + Finish?.serialize(writer.Finish); + break; + case WHICH.Resolve: + Resolve?.serialize(writer.Resolve); + break; + case WHICH.Release: + Release?.serialize(writer.Release); + break; + case WHICH.ObsoleteSave: + writer.ObsoleteSave.SetObject(ObsoleteSave); + break; + case WHICH.Bootstrap: + Bootstrap?.serialize(writer.Bootstrap); + break; + case WHICH.ObsoleteDelete: + writer.ObsoleteDelete.SetObject(ObsoleteDelete); + break; + case WHICH.Provide: + Provide?.serialize(writer.Provide); + break; + case WHICH.Accept: + Accept?.serialize(writer.Accept); + break; + case WHICH.Join: + Join?.serialize(writer.Join); + break; + case WHICH.Disembargo: + Disembargo?.serialize(writer.Disembargo); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Rpc.Message Unimplemented + { + get => _which == WHICH.Unimplemented ? (Capnp.Rpc.Message)_content : null; + set + { + _which = WHICH.Unimplemented; + _content = value; + } + } + + public Capnp.Rpc.Exception Abort + { + get => _which == WHICH.Abort ? (Capnp.Rpc.Exception)_content : null; + set + { + _which = WHICH.Abort; + _content = value; + } + } + + public Capnp.Rpc.Call Call + { + get => _which == WHICH.Call ? (Capnp.Rpc.Call)_content : null; + set + { + _which = WHICH.Call; + _content = value; + } + } + + public Capnp.Rpc.Return Return + { + get => _which == WHICH.Return ? (Capnp.Rpc.Return)_content : null; + set + { + _which = WHICH.Return; + _content = value; + } + } + + public Capnp.Rpc.Finish Finish + { + get => _which == WHICH.Finish ? (Capnp.Rpc.Finish)_content : null; + set + { + _which = WHICH.Finish; + _content = value; + } + } + + public Capnp.Rpc.Resolve Resolve + { + get => _which == WHICH.Resolve ? (Capnp.Rpc.Resolve)_content : null; + set + { + _which = WHICH.Resolve; + _content = value; + } + } + + public Capnp.Rpc.Release Release + { + get => _which == WHICH.Release ? (Capnp.Rpc.Release)_content : null; + set + { + _which = WHICH.Release; + _content = value; + } + } + + public AnyPointer ObsoleteSave + { + get => _which == WHICH.ObsoleteSave ? (AnyPointer)_content : null; + set + { + _which = WHICH.ObsoleteSave; + _content = value; + } + } + + public Capnp.Rpc.Bootstrap Bootstrap + { + get => _which == WHICH.Bootstrap ? (Capnp.Rpc.Bootstrap)_content : null; + set + { + _which = WHICH.Bootstrap; + _content = value; + } + } + + public AnyPointer ObsoleteDelete + { + get => _which == WHICH.ObsoleteDelete ? (AnyPointer)_content : null; + set + { + _which = WHICH.ObsoleteDelete; + _content = value; + } + } + + public Capnp.Rpc.Provide Provide + { + get => _which == WHICH.Provide ? (Capnp.Rpc.Provide)_content : null; + set + { + _which = WHICH.Provide; + _content = value; + } + } + + public Capnp.Rpc.Accept Accept + { + get => _which == WHICH.Accept ? (Capnp.Rpc.Accept)_content : null; + set + { + _which = WHICH.Accept; + _content = value; + } + } + + public Capnp.Rpc.Join Join + { + get => _which == WHICH.Join ? (Capnp.Rpc.Join)_content : null; + set + { + _which = WHICH.Join; + _content = value; + } + } + + public Capnp.Rpc.Disembargo Disembargo + { + get => _which == WHICH.Disembargo ? (Capnp.Rpc.Disembargo)_content : null; + set + { + _which = WHICH.Disembargo; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public Capnp.Rpc.Message.READER Unimplemented => which == WHICH.Unimplemented ? ctx.ReadStruct(0, Capnp.Rpc.Message.READER.create) : default; + public Capnp.Rpc.Exception.READER Abort => which == WHICH.Abort ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default; + public Capnp.Rpc.Call.READER Call => which == WHICH.Call ? ctx.ReadStruct(0, Capnp.Rpc.Call.READER.create) : default; + public Capnp.Rpc.Return.READER Return => which == WHICH.Return ? ctx.ReadStruct(0, Capnp.Rpc.Return.READER.create) : default; + public Capnp.Rpc.Finish.READER Finish => which == WHICH.Finish ? ctx.ReadStruct(0, Capnp.Rpc.Finish.READER.create) : default; + public Capnp.Rpc.Resolve.READER Resolve => which == WHICH.Resolve ? ctx.ReadStruct(0, Capnp.Rpc.Resolve.READER.create) : default; + public Capnp.Rpc.Release.READER Release => which == WHICH.Release ? ctx.ReadStruct(0, Capnp.Rpc.Release.READER.create) : default; + public DeserializerState ObsoleteSave => which == WHICH.ObsoleteSave ? ctx.StructReadPointer(0) : default; + public Capnp.Rpc.Bootstrap.READER Bootstrap => which == WHICH.Bootstrap ? ctx.ReadStruct(0, Capnp.Rpc.Bootstrap.READER.create) : default; + public DeserializerState ObsoleteDelete => which == WHICH.ObsoleteDelete ? ctx.StructReadPointer(0) : default; + public Capnp.Rpc.Provide.READER Provide => which == WHICH.Provide ? ctx.ReadStruct(0, Capnp.Rpc.Provide.READER.create) : default; + public Capnp.Rpc.Accept.READER Accept => which == WHICH.Accept ? ctx.ReadStruct(0, Capnp.Rpc.Accept.READER.create) : default; + public Capnp.Rpc.Join.READER Join => which == WHICH.Join ? ctx.ReadStruct(0, Capnp.Rpc.Join.READER.create) : default; + public Capnp.Rpc.Disembargo.READER Disembargo => which == WHICH.Disembargo ? ctx.ReadStruct(0, Capnp.Rpc.Disembargo.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public Capnp.Rpc.Message.WRITER Unimplemented + { + get => which == WHICH.Unimplemented ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Exception.WRITER Abort + { + get => which == WHICH.Abort ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Call.WRITER Call + { + get => which == WHICH.Call ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Return.WRITER Return + { + get => which == WHICH.Return ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Finish.WRITER Finish + { + get => which == WHICH.Finish ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Resolve.WRITER Resolve + { + get => which == WHICH.Resolve ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Release.WRITER Release + { + get => which == WHICH.Release ? BuildPointer(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState ObsoleteSave + { + get => which == WHICH.ObsoleteSave ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Bootstrap.WRITER Bootstrap + { + get => which == WHICH.Bootstrap ? BuildPointer(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState ObsoleteDelete + { + get => which == WHICH.ObsoleteDelete ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Provide.WRITER Provide + { + get => which == WHICH.Provide ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Accept.WRITER Accept + { + get => which == WHICH.Accept ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Join.WRITER Join + { + get => which == WHICH.Join ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Disembargo.WRITER Disembargo + { + get => which == WHICH.Disembargo ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Bootstrap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + DeprecatedObjectId = CapnpSerializable.Create(reader.DeprecatedObjectId); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.DeprecatedObjectId.SetObject(DeprecatedObjectId); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public AnyPointer DeprecatedObjectId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public DeserializerState DeprecatedObjectId => ctx.StructReadPointer(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public DynamicSerializerState DeprecatedObjectId + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class Call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Target = CapnpSerializable.Create(reader.Target); + InterfaceId = reader.InterfaceId; + MethodId = reader.MethodId; + Params = CapnpSerializable.Create(reader.Params); + SendResultsTo = CapnpSerializable.Create(reader.SendResultsTo); + AllowThirdPartyTailCall = reader.AllowThirdPartyTailCall; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + Target?.serialize(writer.Target); + writer.InterfaceId = InterfaceId; + writer.MethodId = MethodId; + Params?.serialize(writer.Params); + SendResultsTo?.serialize(writer.SendResultsTo); + writer.AllowThirdPartyTailCall = AllowThirdPartyTailCall; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public ulong InterfaceId + { + get; + set; + } + + public ushort MethodId + { + get; + set; + } + + public Capnp.Rpc.Payload Params + { + get; + set; + } + + public Capnp.Rpc.Call.@sendResultsTo SendResultsTo + { + get; + set; + } + + public bool AllowThirdPartyTailCall + { + get; + set; + } + + = false; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public ulong InterfaceId => ctx.ReadDataULong(64UL, 0UL); + public ushort MethodId => ctx.ReadDataUShort(32UL, (ushort)0); + public Capnp.Rpc.Payload.READER Params => ctx.ReadStruct(1, Capnp.Rpc.Payload.READER.create); + public @sendResultsTo.READER SendResultsTo => new @sendResultsTo.READER(ctx); + public bool AllowThirdPartyTailCall => ctx.ReadDataBool(128UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 3); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public ulong InterfaceId + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public ushort MethodId + { + get => this.ReadDataUShort(32UL, (ushort)0); + set => this.WriteData(32UL, value, (ushort)0); + } + + public Capnp.Rpc.Payload.WRITER Params + { + get => BuildPointer(1); + set => Link(1, value); + } + + public @sendResultsTo.WRITER SendResultsTo + { + get => Rewrap<@sendResultsTo.WRITER>(); + } + + public bool AllowThirdPartyTailCall + { + get => this.ReadDataBool(128UL, false); + set => this.WriteData(128UL, value, false); + } + } + + public class @sendResultsTo : ICapnpSerializable + { + public enum WHICH : ushort + { + Caller = 0, + Yourself = 1, + ThirdParty = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Caller: + which = reader.which; + break; + case WHICH.Yourself: + which = reader.which; + break; + case WHICH.ThirdParty: + ThirdParty = CapnpSerializable.Create(reader.ThirdParty); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Caller: + break; + case WHICH.Yourself: + break; + case WHICH.ThirdParty: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Caller: + break; + case WHICH.Yourself: + break; + case WHICH.ThirdParty: + writer.ThirdParty.SetObject(ThirdParty); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer ThirdParty + { + get => _which == WHICH.ThirdParty ? (AnyPointer)_content : null; + set + { + _which = WHICH.ThirdParty; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public DeserializerState ThirdParty => which == WHICH.ThirdParty ? ctx.StructReadPointer(2) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public DynamicSerializerState ThirdParty + { + get => which == WHICH.ThirdParty ? BuildPointer(2) : default; + set => Link(2, value); + } + } + } + } + + public class Return : ICapnpSerializable + { + public enum WHICH : ushort + { + Results = 0, + Exception = 1, + Canceled = 2, + ResultsSentElsewhere = 3, + TakeFromOtherQuestion = 4, + AcceptFromThirdParty = 5, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Results: + Results = CapnpSerializable.Create(reader.Results); + break; + case WHICH.Exception: + Exception = CapnpSerializable.Create(reader.Exception); + break; + case WHICH.Canceled: + which = reader.which; + break; + case WHICH.ResultsSentElsewhere: + which = reader.which; + break; + case WHICH.TakeFromOtherQuestion: + TakeFromOtherQuestion = reader.TakeFromOtherQuestion; + break; + case WHICH.AcceptFromThirdParty: + AcceptFromThirdParty = CapnpSerializable.Create(reader.AcceptFromThirdParty); + break; + } + + AnswerId = reader.AnswerId; + ReleaseParamCaps = reader.ReleaseParamCaps; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Results: + _content = null; + break; + case WHICH.Exception: + _content = null; + break; + case WHICH.Canceled: + break; + case WHICH.ResultsSentElsewhere: + break; + case WHICH.TakeFromOtherQuestion: + _content = 0; + break; + case WHICH.AcceptFromThirdParty: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Results: + Results?.serialize(writer.Results); + break; + case WHICH.Exception: + Exception?.serialize(writer.Exception); + break; + case WHICH.Canceled: + break; + case WHICH.ResultsSentElsewhere: + break; + case WHICH.TakeFromOtherQuestion: + writer.TakeFromOtherQuestion = TakeFromOtherQuestion.Value; + break; + case WHICH.AcceptFromThirdParty: + writer.AcceptFromThirdParty.SetObject(AcceptFromThirdParty); + break; + } + + writer.AnswerId = AnswerId; + writer.ReleaseParamCaps = ReleaseParamCaps; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint AnswerId + { + get; + set; + } + + public bool ReleaseParamCaps + { + get; + set; + } + + = true; + public Capnp.Rpc.Payload Results + { + get => _which == WHICH.Results ? (Capnp.Rpc.Payload)_content : null; + set + { + _which = WHICH.Results; + _content = value; + } + } + + public Capnp.Rpc.Exception Exception + { + get => _which == WHICH.Exception ? (Capnp.Rpc.Exception)_content : null; + set + { + _which = WHICH.Exception; + _content = value; + } + } + + public uint? TakeFromOtherQuestion + { + get => _which == WHICH.TakeFromOtherQuestion ? (uint? )_content : null; + set + { + _which = WHICH.TakeFromOtherQuestion; + _content = value; + } + } + + public AnyPointer AcceptFromThirdParty + { + get => _which == WHICH.AcceptFromThirdParty ? (AnyPointer)_content : null; + set + { + _which = WHICH.AcceptFromThirdParty; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public uint AnswerId => ctx.ReadDataUInt(0UL, 0U); + public bool ReleaseParamCaps => ctx.ReadDataBool(32UL, true); + public Capnp.Rpc.Payload.READER Results => which == WHICH.Results ? ctx.ReadStruct(0, Capnp.Rpc.Payload.READER.create) : default; + public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default; + public uint TakeFromOtherQuestion => which == WHICH.TakeFromOtherQuestion ? ctx.ReadDataUInt(64UL, 0U) : default; + public DeserializerState AcceptFromThirdParty => which == WHICH.AcceptFromThirdParty ? ctx.StructReadPointer(0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public uint AnswerId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public bool ReleaseParamCaps + { + get => this.ReadDataBool(32UL, true); + set => this.WriteData(32UL, value, true); + } + + public Capnp.Rpc.Payload.WRITER Results + { + get => which == WHICH.Results ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Exception.WRITER Exception + { + get => which == WHICH.Exception ? BuildPointer(0) : default; + set => Link(0, value); + } + + public uint TakeFromOtherQuestion + { + get => which == WHICH.TakeFromOtherQuestion ? this.ReadDataUInt(64UL, 0U) : default; + set => this.WriteData(64UL, value, 0U); + } + + public DynamicSerializerState AcceptFromThirdParty + { + get => which == WHICH.AcceptFromThirdParty ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Finish : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + ReleaseResultCaps = reader.ReleaseResultCaps; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.ReleaseResultCaps = ReleaseResultCaps; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public bool ReleaseResultCaps + { + get; + set; + } + + = true; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public bool ReleaseResultCaps => ctx.ReadDataBool(32UL, true); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public bool ReleaseResultCaps + { + get => this.ReadDataBool(32UL, true); + set => this.WriteData(32UL, value, true); + } + } + } + + public class Resolve : ICapnpSerializable + { + public enum WHICH : ushort + { + Cap = 0, + Exception = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Cap: + Cap = CapnpSerializable.Create(reader.Cap); + break; + case WHICH.Exception: + Exception = CapnpSerializable.Create(reader.Exception); + break; + } + + PromiseId = reader.PromiseId; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Cap: + _content = null; + break; + case WHICH.Exception: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Cap: + Cap?.serialize(writer.Cap); + break; + case WHICH.Exception: + Exception?.serialize(writer.Exception); + break; + } + + writer.PromiseId = PromiseId; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint PromiseId + { + get; + set; + } + + public Capnp.Rpc.CapDescriptor Cap + { + get => _which == WHICH.Cap ? (Capnp.Rpc.CapDescriptor)_content : null; + set + { + _which = WHICH.Cap; + _content = value; + } + } + + public Capnp.Rpc.Exception Exception + { + get => _which == WHICH.Exception ? (Capnp.Rpc.Exception)_content : null; + set + { + _which = WHICH.Exception; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public uint PromiseId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.CapDescriptor.READER Cap => which == WHICH.Cap ? ctx.ReadStruct(0, Capnp.Rpc.CapDescriptor.READER.create) : default; + public Capnp.Rpc.Exception.READER Exception => which == WHICH.Exception ? ctx.ReadStruct(0, Capnp.Rpc.Exception.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public uint PromiseId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.CapDescriptor.WRITER Cap + { + get => which == WHICH.Cap ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.Exception.WRITER Exception + { + get => which == WHICH.Exception ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Release : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + ReferenceCount = reader.ReferenceCount; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + writer.ReferenceCount = ReferenceCount; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Id + { + get; + set; + } + + public uint ReferenceCount + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint Id => ctx.ReadDataUInt(0UL, 0U); + public uint ReferenceCount => ctx.ReadDataUInt(32UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint Id + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public uint ReferenceCount + { + get => this.ReadDataUInt(32UL, 0U); + set => this.WriteData(32UL, value, 0U); + } + } + } + + public class Disembargo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Target = CapnpSerializable.Create(reader.Target); + Context = CapnpSerializable.Create(reader.Context); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Target?.serialize(writer.Target); + Context?.serialize(writer.Context); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public Capnp.Rpc.Disembargo.@context Context + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public @context.READER Context => new @context.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public @context.WRITER Context + { + get => Rewrap<@context.WRITER>(); + } + } + + public class @context : ICapnpSerializable + { + public enum WHICH : ushort + { + SenderLoopback = 0, + ReceiverLoopback = 1, + Accept = 2, + Provide = 3, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.SenderLoopback: + SenderLoopback = reader.SenderLoopback; + break; + case WHICH.ReceiverLoopback: + ReceiverLoopback = reader.ReceiverLoopback; + break; + case WHICH.Accept: + which = reader.which; + break; + case WHICH.Provide: + Provide = reader.Provide; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.SenderLoopback: + _content = 0; + break; + case WHICH.ReceiverLoopback: + _content = 0; + break; + case WHICH.Accept: + break; + case WHICH.Provide: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.SenderLoopback: + writer.SenderLoopback = SenderLoopback.Value; + break; + case WHICH.ReceiverLoopback: + writer.ReceiverLoopback = ReceiverLoopback.Value; + break; + case WHICH.Accept: + break; + case WHICH.Provide: + writer.Provide = Provide.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? SenderLoopback + { + get => _which == WHICH.SenderLoopback ? (uint? )_content : null; + set + { + _which = WHICH.SenderLoopback; + _content = value; + } + } + + public uint? ReceiverLoopback + { + get => _which == WHICH.ReceiverLoopback ? (uint? )_content : null; + set + { + _which = WHICH.ReceiverLoopback; + _content = value; + } + } + + public uint? Provide + { + get => _which == WHICH.Provide ? (uint? )_content : null; + set + { + _which = WHICH.Provide; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public uint SenderLoopback => which == WHICH.SenderLoopback ? ctx.ReadDataUInt(0UL, 0U) : default; + public uint ReceiverLoopback => which == WHICH.ReceiverLoopback ? ctx.ReadDataUInt(0UL, 0U) : default; + public uint Provide => which == WHICH.Provide ? ctx.ReadDataUInt(0UL, 0U) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public uint SenderLoopback + { + get => which == WHICH.SenderLoopback ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + + public uint ReceiverLoopback + { + get => which == WHICH.ReceiverLoopback ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + + public uint Provide + { + get => which == WHICH.Provide ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + } + } + } + + public class Provide : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Target = CapnpSerializable.Create(reader.Target); + Recipient = CapnpSerializable.Create(reader.Recipient); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + Target?.serialize(writer.Target); + writer.Recipient.SetObject(Recipient); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public AnyPointer Recipient + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public DeserializerState Recipient => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Recipient + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class Accept : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Provision = CapnpSerializable.Create(reader.Provision); + Embargo = reader.Embargo; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.Provision.SetObject(Provision); + writer.Embargo = Embargo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public AnyPointer Provision + { + get; + set; + } + + public bool Embargo + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public DeserializerState Provision => ctx.StructReadPointer(0); + public bool Embargo => ctx.ReadDataBool(32UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public DynamicSerializerState Provision + { + get => BuildPointer(0); + set => Link(0, value); + } + + public bool Embargo + { + get => this.ReadDataBool(32UL, false); + set => this.WriteData(32UL, value, false); + } + } + } + + public class Join : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Target = CapnpSerializable.Create(reader.Target); + KeyPart = CapnpSerializable.Create(reader.KeyPart); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + Target?.serialize(writer.Target); + writer.KeyPart.SetObject(KeyPart); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public Capnp.Rpc.MessageTarget Target + { + get; + set; + } + + public AnyPointer KeyPart + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public Capnp.Rpc.MessageTarget.READER Target => ctx.ReadStruct(0, Capnp.Rpc.MessageTarget.READER.create); + public DeserializerState KeyPart => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.MessageTarget.WRITER Target + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState KeyPart + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class MessageTarget : ICapnpSerializable + { + public enum WHICH : ushort + { + ImportedCap = 0, + PromisedAnswer = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.ImportedCap: + ImportedCap = reader.ImportedCap; + break; + case WHICH.PromisedAnswer: + PromisedAnswer = CapnpSerializable.Create(reader.PromisedAnswer); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.ImportedCap: + _content = 0; + break; + case WHICH.PromisedAnswer: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.ImportedCap: + writer.ImportedCap = ImportedCap.Value; + break; + case WHICH.PromisedAnswer: + PromisedAnswer?.serialize(writer.PromisedAnswer); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? ImportedCap + { + get => _which == WHICH.ImportedCap ? (uint? )_content : null; + set + { + _which = WHICH.ImportedCap; + _content = value; + } + } + + public Capnp.Rpc.PromisedAnswer PromisedAnswer + { + get => _which == WHICH.PromisedAnswer ? (Capnp.Rpc.PromisedAnswer)_content : null; + set + { + _which = WHICH.PromisedAnswer; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public uint ImportedCap => which == WHICH.ImportedCap ? ctx.ReadDataUInt(0UL, 0U) : default; + public Capnp.Rpc.PromisedAnswer.READER PromisedAnswer => which == WHICH.PromisedAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public uint ImportedCap + { + get => which == WHICH.ImportedCap ? this.ReadDataUInt(0UL, 0U) : default; + set => this.WriteData(0UL, value, 0U); + } + + public Capnp.Rpc.PromisedAnswer.WRITER PromisedAnswer + { + get => which == WHICH.PromisedAnswer ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Payload : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Content = CapnpSerializable.Create(reader.Content); + CapTable = reader.CapTable.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Content.SetObject(Content); + writer.CapTable.Init(CapTable, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer Content + { + get; + set; + } + + public IReadOnlyList CapTable + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Content => ctx.StructReadPointer(0); + public IReadOnlyList CapTable => ctx.ReadList(1).Cast(Capnp.Rpc.CapDescriptor.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Content + { + get => BuildPointer(0); + set => Link(0, value); + } + + public ListOfStructsSerializer CapTable + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + public class CapDescriptor : ICapnpSerializable + { + public enum WHICH : ushort + { + None = 0, + SenderHosted = 1, + SenderPromise = 2, + ReceiverHosted = 3, + ReceiverAnswer = 4, + ThirdPartyHosted = 5, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.None: + which = reader.which; + break; + case WHICH.SenderHosted: + SenderHosted = reader.SenderHosted; + break; + case WHICH.SenderPromise: + SenderPromise = reader.SenderPromise; + break; + case WHICH.ReceiverHosted: + ReceiverHosted = reader.ReceiverHosted; + break; + case WHICH.ReceiverAnswer: + ReceiverAnswer = CapnpSerializable.Create(reader.ReceiverAnswer); + break; + case WHICH.ThirdPartyHosted: + ThirdPartyHosted = CapnpSerializable.Create(reader.ThirdPartyHosted); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.None: + break; + case WHICH.SenderHosted: + _content = 0; + break; + case WHICH.SenderPromise: + _content = 0; + break; + case WHICH.ReceiverHosted: + _content = 0; + break; + case WHICH.ReceiverAnswer: + _content = null; + break; + case WHICH.ThirdPartyHosted: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.None: + break; + case WHICH.SenderHosted: + writer.SenderHosted = SenderHosted.Value; + break; + case WHICH.SenderPromise: + writer.SenderPromise = SenderPromise.Value; + break; + case WHICH.ReceiverHosted: + writer.ReceiverHosted = ReceiverHosted.Value; + break; + case WHICH.ReceiverAnswer: + ReceiverAnswer?.serialize(writer.ReceiverAnswer); + break; + case WHICH.ThirdPartyHosted: + ThirdPartyHosted?.serialize(writer.ThirdPartyHosted); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint? SenderHosted + { + get => _which == WHICH.SenderHosted ? (uint? )_content : null; + set + { + _which = WHICH.SenderHosted; + _content = value; + } + } + + public uint? SenderPromise + { + get => _which == WHICH.SenderPromise ? (uint? )_content : null; + set + { + _which = WHICH.SenderPromise; + _content = value; + } + } + + public uint? ReceiverHosted + { + get => _which == WHICH.ReceiverHosted ? (uint? )_content : null; + set + { + _which = WHICH.ReceiverHosted; + _content = value; + } + } + + public Capnp.Rpc.PromisedAnswer ReceiverAnswer + { + get => _which == WHICH.ReceiverAnswer ? (Capnp.Rpc.PromisedAnswer)_content : null; + set + { + _which = WHICH.ReceiverAnswer; + _content = value; + } + } + + public Capnp.Rpc.ThirdPartyCapDescriptor ThirdPartyHosted + { + get => _which == WHICH.ThirdPartyHosted ? (Capnp.Rpc.ThirdPartyCapDescriptor)_content : null; + set + { + _which = WHICH.ThirdPartyHosted; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public uint SenderHosted => which == WHICH.SenderHosted ? ctx.ReadDataUInt(32UL, 0U) : default; + public uint SenderPromise => which == WHICH.SenderPromise ? ctx.ReadDataUInt(32UL, 0U) : default; + public uint ReceiverHosted => which == WHICH.ReceiverHosted ? ctx.ReadDataUInt(32UL, 0U) : default; + public Capnp.Rpc.PromisedAnswer.READER ReceiverAnswer => which == WHICH.ReceiverAnswer ? ctx.ReadStruct(0, Capnp.Rpc.PromisedAnswer.READER.create) : default; + public Capnp.Rpc.ThirdPartyCapDescriptor.READER ThirdPartyHosted => which == WHICH.ThirdPartyHosted ? ctx.ReadStruct(0, Capnp.Rpc.ThirdPartyCapDescriptor.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public uint SenderHosted + { + get => which == WHICH.SenderHosted ? this.ReadDataUInt(32UL, 0U) : default; + set => this.WriteData(32UL, value, 0U); + } + + public uint SenderPromise + { + get => which == WHICH.SenderPromise ? this.ReadDataUInt(32UL, 0U) : default; + set => this.WriteData(32UL, value, 0U); + } + + public uint ReceiverHosted + { + get => which == WHICH.ReceiverHosted ? this.ReadDataUInt(32UL, 0U) : default; + set => this.WriteData(32UL, value, 0U); + } + + public Capnp.Rpc.PromisedAnswer.WRITER ReceiverAnswer + { + get => which == WHICH.ReceiverAnswer ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnp.Rpc.ThirdPartyCapDescriptor.WRITER ThirdPartyHosted + { + get => which == WHICH.ThirdPartyHosted ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class PromisedAnswer : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + QuestionId = reader.QuestionId; + Transform = reader.Transform.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.QuestionId = QuestionId; + writer.Transform.Init(Transform, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint QuestionId + { + get; + set; + } + + public IReadOnlyList Transform + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint QuestionId => ctx.ReadDataUInt(0UL, 0U); + public IReadOnlyList Transform => ctx.ReadList(0).Cast(Capnp.Rpc.PromisedAnswer.Op.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint QuestionId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public ListOfStructsSerializer Transform + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + + public class Op : ICapnpSerializable + { + public enum WHICH : ushort + { + Noop = 0, + GetPointerField = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Noop: + which = reader.which; + break; + case WHICH.GetPointerField: + GetPointerField = reader.GetPointerField; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Noop: + break; + case WHICH.GetPointerField: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Noop: + break; + case WHICH.GetPointerField: + writer.GetPointerField = GetPointerField.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort? GetPointerField + { + get => _which == WHICH.GetPointerField ? (ushort? )_content : null; + set + { + _which = WHICH.GetPointerField; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public ushort GetPointerField => which == WHICH.GetPointerField ? ctx.ReadDataUShort(16UL, (ushort)0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public ushort GetPointerField + { + get => which == WHICH.GetPointerField ? this.ReadDataUShort(16UL, (ushort)0) : default; + set => this.WriteData(16UL, value, (ushort)0); + } + } + } + } + + public class ThirdPartyCapDescriptor : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = CapnpSerializable.Create(reader.Id); + VineId = reader.VineId; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id.SetObject(Id); + writer.VineId = VineId; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer Id + { + get; + set; + } + + public uint VineId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Id => ctx.StructReadPointer(0); + public uint VineId => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public DynamicSerializerState Id + { + get => BuildPointer(0); + set => Link(0, value); + } + + public uint VineId + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + + public class Exception : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Reason = reader.Reason; + ObsoleteIsCallersFault = reader.ObsoleteIsCallersFault; + ObsoleteDurability = reader.ObsoleteDurability; + TheType = reader.TheType; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Reason = Reason; + writer.ObsoleteIsCallersFault = ObsoleteIsCallersFault; + writer.ObsoleteDurability = ObsoleteDurability; + writer.TheType = TheType; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Reason + { + get; + set; + } + + public bool ObsoleteIsCallersFault + { + get; + set; + } + + public ushort ObsoleteDurability + { + get; + set; + } + + public Capnp.Rpc.Exception.Type TheType + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Reason => ctx.ReadText(0, ""); + public bool ObsoleteIsCallersFault => ctx.ReadDataBool(0UL, false); + public ushort ObsoleteDurability => ctx.ReadDataUShort(16UL, (ushort)0); + public Capnp.Rpc.Exception.Type TheType => (Capnp.Rpc.Exception.Type)ctx.ReadDataUShort(32UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public string Reason + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public bool ObsoleteIsCallersFault + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public ushort ObsoleteDurability + { + get => this.ReadDataUShort(16UL, (ushort)0); + set => this.WriteData(16UL, value, (ushort)0); + } + + public Capnp.Rpc.Exception.Type TheType + { + get => (Capnp.Rpc.Exception.Type)this.ReadDataUShort(32UL, (ushort)0); + set => this.WriteData(32UL, (ushort)value, (ushort)0); + } + } + + public enum Type : ushort + { + failed, + overloaded, + disconnected, + unimplemented + } + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/schema.capnp.cs b/MsBuildGenerationTest/capnp/schema.capnp.cs new file mode 100644 index 0000000..63d6b35 --- /dev/null +++ b/MsBuildGenerationTest/capnp/schema.capnp.cs @@ -0,0 +1,4309 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnp.Schema +{ + public class Node : ICapnpSerializable + { + public enum WHICH : ushort + { + File = 0, + Struct = 1, + Enum = 2, + Interface = 3, + Const = 4, + Annotation = 5, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.File: + which = reader.which; + break; + case WHICH.Struct: + Struct = CapnpSerializable.Create(reader.Struct); + break; + case WHICH.Enum: + Enum = CapnpSerializable.Create(reader.Enum); + break; + case WHICH.Interface: + Interface = CapnpSerializable.Create(reader.Interface); + break; + case WHICH.Const: + Const = CapnpSerializable.Create(reader.Const); + break; + case WHICH.Annotation: + Annotation = CapnpSerializable.Create(reader.Annotation); + break; + } + + Id = reader.Id; + DisplayName = reader.DisplayName; + DisplayNamePrefixLength = reader.DisplayNamePrefixLength; + ScopeId = reader.ScopeId; + NestedNodes = reader.NestedNodes.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + Annotations = reader.Annotations.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + Parameters = reader.Parameters.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + IsGeneric = reader.IsGeneric; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.File: + break; + case WHICH.Struct: + _content = null; + break; + case WHICH.Enum: + _content = null; + break; + case WHICH.Interface: + _content = null; + break; + case WHICH.Const: + _content = null; + break; + case WHICH.Annotation: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.File: + break; + case WHICH.Struct: + Struct?.serialize(writer.Struct); + break; + case WHICH.Enum: + Enum?.serialize(writer.Enum); + break; + case WHICH.Interface: + Interface?.serialize(writer.Interface); + break; + case WHICH.Const: + Const?.serialize(writer.Const); + break; + case WHICH.Annotation: + Annotation?.serialize(writer.Annotation); + break; + } + + writer.Id = Id; + writer.DisplayName = DisplayName; + writer.DisplayNamePrefixLength = DisplayNamePrefixLength; + writer.ScopeId = ScopeId; + writer.NestedNodes.Init(NestedNodes, (_s1, _v1) => _v1?.serialize(_s1)); + writer.Annotations.Init(Annotations, (_s1, _v1) => _v1?.serialize(_s1)); + writer.Parameters.Init(Parameters, (_s1, _v1) => _v1?.serialize(_s1)); + writer.IsGeneric = IsGeneric; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Id + { + get; + set; + } + + public string DisplayName + { + get; + set; + } + + public uint DisplayNamePrefixLength + { + get; + set; + } + + public ulong ScopeId + { + get; + set; + } + + public IReadOnlyList NestedNodes + { + get; + set; + } + + public IReadOnlyList Annotations + { + get; + set; + } + + public Capnp.Schema.Node.@struct Struct + { + get => _which == WHICH.Struct ? (Capnp.Schema.Node.@struct)_content : null; + set + { + _which = WHICH.Struct; + _content = value; + } + } + + public Capnp.Schema.Node.@enum Enum + { + get => _which == WHICH.Enum ? (Capnp.Schema.Node.@enum)_content : null; + set + { + _which = WHICH.Enum; + _content = value; + } + } + + public Capnp.Schema.Node.@interface Interface + { + get => _which == WHICH.Interface ? (Capnp.Schema.Node.@interface)_content : null; + set + { + _which = WHICH.Interface; + _content = value; + } + } + + public Capnp.Schema.Node.@const Const + { + get => _which == WHICH.Const ? (Capnp.Schema.Node.@const)_content : null; + set + { + _which = WHICH.Const; + _content = value; + } + } + + public Capnp.Schema.Node.@annotation Annotation + { + get => _which == WHICH.Annotation ? (Capnp.Schema.Node.@annotation)_content : null; + set + { + _which = WHICH.Annotation; + _content = value; + } + } + + public IReadOnlyList Parameters + { + get; + set; + } + + public bool IsGeneric + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(96U, (ushort)0); + public ulong Id => ctx.ReadDataULong(0UL, 0UL); + public string DisplayName => ctx.ReadText(0, ""); + public uint DisplayNamePrefixLength => ctx.ReadDataUInt(64UL, 0U); + public ulong ScopeId => ctx.ReadDataULong(128UL, 0UL); + public IReadOnlyList NestedNodes => ctx.ReadList(1).Cast(Capnp.Schema.Node.NestedNode.READER.create); + public IReadOnlyList Annotations => ctx.ReadList(2).Cast(Capnp.Schema.Annotation.READER.create); + public @struct.READER Struct => which == WHICH.Struct ? new @struct.READER(ctx) : default; + public @enum.READER Enum => which == WHICH.Enum ? new @enum.READER(ctx) : default; + public @interface.READER Interface => which == WHICH.Interface ? new @interface.READER(ctx) : default; + public @const.READER Const => which == WHICH.Const ? new @const.READER(ctx) : default; + public @annotation.READER Annotation => which == WHICH.Annotation ? new @annotation.READER(ctx) : default; + public IReadOnlyList Parameters => ctx.ReadList(5).Cast(Capnp.Schema.Node.Parameter.READER.create); + public bool IsGeneric => ctx.ReadDataBool(288UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(5, 6); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(96U, (ushort)0); + set => this.WriteData(96U, (ushort)value, (ushort)0); + } + + public ulong Id + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public string DisplayName + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public uint DisplayNamePrefixLength + { + get => this.ReadDataUInt(64UL, 0U); + set => this.WriteData(64UL, value, 0U); + } + + public ulong ScopeId + { + get => this.ReadDataULong(128UL, 0UL); + set => this.WriteData(128UL, value, 0UL); + } + + public ListOfStructsSerializer NestedNodes + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public ListOfStructsSerializer Annotations + { + get => BuildPointer>(2); + set => Link(2, value); + } + + public @struct.WRITER Struct + { + get => which == WHICH.Struct ? Rewrap<@struct.WRITER>() : default; + } + + public @enum.WRITER Enum + { + get => which == WHICH.Enum ? Rewrap<@enum.WRITER>() : default; + } + + public @interface.WRITER Interface + { + get => which == WHICH.Interface ? Rewrap<@interface.WRITER>() : default; + } + + public @const.WRITER Const + { + get => which == WHICH.Const ? Rewrap<@const.WRITER>() : default; + } + + public @annotation.WRITER Annotation + { + get => which == WHICH.Annotation ? Rewrap<@annotation.WRITER>() : default; + } + + public ListOfStructsSerializer Parameters + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public bool IsGeneric + { + get => this.ReadDataBool(288UL, false); + set => this.WriteData(288UL, value, false); + } + } + + public class @struct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + DataWordCount = reader.DataWordCount; + PointerCount = reader.PointerCount; + PreferredListEncoding = reader.PreferredListEncoding; + IsGroup = reader.IsGroup; + DiscriminantCount = reader.DiscriminantCount; + DiscriminantOffset = reader.DiscriminantOffset; + Fields = reader.Fields.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.DataWordCount = DataWordCount; + writer.PointerCount = PointerCount; + writer.PreferredListEncoding = PreferredListEncoding; + writer.IsGroup = IsGroup; + writer.DiscriminantCount = DiscriminantCount; + writer.DiscriminantOffset = DiscriminantOffset; + writer.Fields.Init(Fields, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort DataWordCount + { + get; + set; + } + + public ushort PointerCount + { + get; + set; + } + + public Capnp.Schema.ElementSize PreferredListEncoding + { + get; + set; + } + + public bool IsGroup + { + get; + set; + } + + public ushort DiscriminantCount + { + get; + set; + } + + public uint DiscriminantOffset + { + get; + set; + } + + public IReadOnlyList Fields + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ushort DataWordCount => ctx.ReadDataUShort(112UL, (ushort)0); + public ushort PointerCount => ctx.ReadDataUShort(192UL, (ushort)0); + public Capnp.Schema.ElementSize PreferredListEncoding => (Capnp.Schema.ElementSize)ctx.ReadDataUShort(208UL, (ushort)0); + public bool IsGroup => ctx.ReadDataBool(224UL, false); + public ushort DiscriminantCount => ctx.ReadDataUShort(240UL, (ushort)0); + public uint DiscriminantOffset => ctx.ReadDataUInt(256UL, 0U); + public IReadOnlyList Fields => ctx.ReadList(3).Cast(Capnp.Schema.Field.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ushort DataWordCount + { + get => this.ReadDataUShort(112UL, (ushort)0); + set => this.WriteData(112UL, value, (ushort)0); + } + + public ushort PointerCount + { + get => this.ReadDataUShort(192UL, (ushort)0); + set => this.WriteData(192UL, value, (ushort)0); + } + + public Capnp.Schema.ElementSize PreferredListEncoding + { + get => (Capnp.Schema.ElementSize)this.ReadDataUShort(208UL, (ushort)0); + set => this.WriteData(208UL, (ushort)value, (ushort)0); + } + + public bool IsGroup + { + get => this.ReadDataBool(224UL, false); + set => this.WriteData(224UL, value, false); + } + + public ushort DiscriminantCount + { + get => this.ReadDataUShort(240UL, (ushort)0); + set => this.WriteData(240UL, value, (ushort)0); + } + + public uint DiscriminantOffset + { + get => this.ReadDataUInt(256UL, 0U); + set => this.WriteData(256UL, value, 0U); + } + + public ListOfStructsSerializer Fields + { + get => BuildPointer>(3); + set => Link(3, value); + } + } + } + + public class @enum : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Enumerants = reader.Enumerants.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Enumerants.Init(Enumerants, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Enumerants + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList Enumerants => ctx.ReadList(3).Cast(Capnp.Schema.Enumerant.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ListOfStructsSerializer Enumerants + { + get => BuildPointer>(3); + set => Link(3, value); + } + } + } + + public class @interface : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Methods = reader.Methods.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + Superclasses = reader.Superclasses.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Methods.Init(Methods, (_s1, _v1) => _v1?.serialize(_s1)); + writer.Superclasses.Init(Superclasses, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Methods + { + get; + set; + } + + public IReadOnlyList Superclasses + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList Methods => ctx.ReadList(3).Cast(Capnp.Schema.Method.READER.create); + public IReadOnlyList Superclasses => ctx.ReadList(4).Cast(Capnp.Schema.Superclass.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ListOfStructsSerializer Methods + { + get => BuildPointer>(3); + set => Link(3, value); + } + + public ListOfStructsSerializer Superclasses + { + get => BuildPointer>(4); + set => Link(4, value); + } + } + } + + public class @const : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Type = CapnpSerializable.Create(reader.Type); + Value = CapnpSerializable.Create(reader.Value); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Type?.serialize(writer.Type); + Value?.serialize(writer.Value); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Schema.Type Type + { + get; + set; + } + + public Capnp.Schema.Value Value + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnp.Schema.Type.READER Type => ctx.ReadStruct(3, Capnp.Schema.Type.READER.create); + public Capnp.Schema.Value.READER Value => ctx.ReadStruct(4, Capnp.Schema.Value.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public Capnp.Schema.Type.WRITER Type + { + get => BuildPointer(3); + set => Link(3, value); + } + + public Capnp.Schema.Value.WRITER Value + { + get => BuildPointer(4); + set => Link(4, value); + } + } + } + + public class @annotation : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Type = CapnpSerializable.Create(reader.Type); + TargetsFile = reader.TargetsFile; + TargetsConst = reader.TargetsConst; + TargetsEnum = reader.TargetsEnum; + TargetsEnumerant = reader.TargetsEnumerant; + TargetsStruct = reader.TargetsStruct; + TargetsField = reader.TargetsField; + TargetsUnion = reader.TargetsUnion; + TargetsGroup = reader.TargetsGroup; + TargetsInterface = reader.TargetsInterface; + TargetsMethod = reader.TargetsMethod; + TargetsParam = reader.TargetsParam; + TargetsAnnotation = reader.TargetsAnnotation; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Type?.serialize(writer.Type); + writer.TargetsFile = TargetsFile; + writer.TargetsConst = TargetsConst; + writer.TargetsEnum = TargetsEnum; + writer.TargetsEnumerant = TargetsEnumerant; + writer.TargetsStruct = TargetsStruct; + writer.TargetsField = TargetsField; + writer.TargetsUnion = TargetsUnion; + writer.TargetsGroup = TargetsGroup; + writer.TargetsInterface = TargetsInterface; + writer.TargetsMethod = TargetsMethod; + writer.TargetsParam = TargetsParam; + writer.TargetsAnnotation = TargetsAnnotation; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Schema.Type Type + { + get; + set; + } + + public bool TargetsFile + { + get; + set; + } + + public bool TargetsConst + { + get; + set; + } + + public bool TargetsEnum + { + get; + set; + } + + public bool TargetsEnumerant + { + get; + set; + } + + public bool TargetsStruct + { + get; + set; + } + + public bool TargetsField + { + get; + set; + } + + public bool TargetsUnion + { + get; + set; + } + + public bool TargetsGroup + { + get; + set; + } + + public bool TargetsInterface + { + get; + set; + } + + public bool TargetsMethod + { + get; + set; + } + + public bool TargetsParam + { + get; + set; + } + + public bool TargetsAnnotation + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnp.Schema.Type.READER Type => ctx.ReadStruct(3, Capnp.Schema.Type.READER.create); + public bool TargetsFile => ctx.ReadDataBool(112UL, false); + public bool TargetsConst => ctx.ReadDataBool(113UL, false); + public bool TargetsEnum => ctx.ReadDataBool(114UL, false); + public bool TargetsEnumerant => ctx.ReadDataBool(115UL, false); + public bool TargetsStruct => ctx.ReadDataBool(116UL, false); + public bool TargetsField => ctx.ReadDataBool(117UL, false); + public bool TargetsUnion => ctx.ReadDataBool(118UL, false); + public bool TargetsGroup => ctx.ReadDataBool(119UL, false); + public bool TargetsInterface => ctx.ReadDataBool(120UL, false); + public bool TargetsMethod => ctx.ReadDataBool(121UL, false); + public bool TargetsParam => ctx.ReadDataBool(122UL, false); + public bool TargetsAnnotation => ctx.ReadDataBool(123UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public Capnp.Schema.Type.WRITER Type + { + get => BuildPointer(3); + set => Link(3, value); + } + + public bool TargetsFile + { + get => this.ReadDataBool(112UL, false); + set => this.WriteData(112UL, value, false); + } + + public bool TargetsConst + { + get => this.ReadDataBool(113UL, false); + set => this.WriteData(113UL, value, false); + } + + public bool TargetsEnum + { + get => this.ReadDataBool(114UL, false); + set => this.WriteData(114UL, value, false); + } + + public bool TargetsEnumerant + { + get => this.ReadDataBool(115UL, false); + set => this.WriteData(115UL, value, false); + } + + public bool TargetsStruct + { + get => this.ReadDataBool(116UL, false); + set => this.WriteData(116UL, value, false); + } + + public bool TargetsField + { + get => this.ReadDataBool(117UL, false); + set => this.WriteData(117UL, value, false); + } + + public bool TargetsUnion + { + get => this.ReadDataBool(118UL, false); + set => this.WriteData(118UL, value, false); + } + + public bool TargetsGroup + { + get => this.ReadDataBool(119UL, false); + set => this.WriteData(119UL, value, false); + } + + public bool TargetsInterface + { + get => this.ReadDataBool(120UL, false); + set => this.WriteData(120UL, value, false); + } + + public bool TargetsMethod + { + get => this.ReadDataBool(121UL, false); + set => this.WriteData(121UL, value, false); + } + + public bool TargetsParam + { + get => this.ReadDataBool(122UL, false); + set => this.WriteData(122UL, value, false); + } + + public bool TargetsAnnotation + { + get => this.ReadDataBool(123UL, false); + set => this.WriteData(123UL, value, false); + } + } + } + + public class Parameter : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Name = reader.Name; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Name = Name; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Name => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class NestedNode : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Name = reader.Name; + Id = reader.Id; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Name = Name; + writer.Id = Id; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + get; + set; + } + + public ulong Id + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Name => ctx.ReadText(0, ""); + public ulong Id => ctx.ReadDataULong(0UL, 0UL); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ulong Id + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + } + } + + public class SourceInfo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + DocComment = reader.DocComment; + Members = reader.Members.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + writer.DocComment = DocComment; + writer.Members.Init(Members, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Id + { + get; + set; + } + + public string DocComment + { + get; + set; + } + + public IReadOnlyList Members + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Id => ctx.ReadDataULong(0UL, 0UL); + public string DocComment => ctx.ReadText(0, ""); + public IReadOnlyList Members => ctx.ReadList(1).Cast(Capnp.Schema.Node.SourceInfo.Member.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public ulong Id + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public string DocComment + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ListOfStructsSerializer Members + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + + public class Member : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + DocComment = reader.DocComment; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.DocComment = DocComment; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string DocComment + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string DocComment => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string DocComment + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + } + } + + public class Field : ICapnpSerializable + { + public enum WHICH : ushort + { + Slot = 0, + Group = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Slot: + Slot = CapnpSerializable.Create(reader.Slot); + break; + case WHICH.Group: + Group = CapnpSerializable.Create(reader.Group); + break; + } + + Name = reader.Name; + CodeOrder = reader.CodeOrder; + Annotations = reader.Annotations.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + DiscriminantValue = reader.DiscriminantValue; + Ordinal = CapnpSerializable.Create(reader.Ordinal); + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Slot: + _content = null; + break; + case WHICH.Group: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Slot: + Slot?.serialize(writer.Slot); + break; + case WHICH.Group: + Group?.serialize(writer.Group); + break; + } + + writer.Name = Name; + writer.CodeOrder = CodeOrder; + writer.Annotations.Init(Annotations, (_s1, _v1) => _v1?.serialize(_s1)); + writer.DiscriminantValue = DiscriminantValue; + Ordinal?.serialize(writer.Ordinal); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + get; + set; + } + + public ushort CodeOrder + { + get; + set; + } + + public IReadOnlyList Annotations + { + get; + set; + } + + public ushort DiscriminantValue + { + get; + set; + } + + = 65535; + public Capnp.Schema.Field.@slot Slot + { + get => _which == WHICH.Slot ? (Capnp.Schema.Field.@slot)_content : null; + set + { + _which = WHICH.Slot; + _content = value; + } + } + + public Capnp.Schema.Field.@group Group + { + get => _which == WHICH.Group ? (Capnp.Schema.Field.@group)_content : null; + set + { + _which = WHICH.Group; + _content = value; + } + } + + public Capnp.Schema.Field.@ordinal Ordinal + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(64U, (ushort)0); + public string Name => ctx.ReadText(0, ""); + public ushort CodeOrder => ctx.ReadDataUShort(0UL, (ushort)0); + public IReadOnlyList Annotations => ctx.ReadList(1).Cast(Capnp.Schema.Annotation.READER.create); + public ushort DiscriminantValue => ctx.ReadDataUShort(16UL, (ushort)65535); + public @slot.READER Slot => which == WHICH.Slot ? new @slot.READER(ctx) : default; + public @group.READER Group => which == WHICH.Group ? new @group.READER(ctx) : default; + public @ordinal.READER Ordinal => new @ordinal.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 4); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(64U, (ushort)0); + set => this.WriteData(64U, (ushort)value, (ushort)0); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ushort CodeOrder + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + + public ListOfStructsSerializer Annotations + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public ushort DiscriminantValue + { + get => this.ReadDataUShort(16UL, (ushort)65535); + set => this.WriteData(16UL, value, (ushort)65535); + } + + public @slot.WRITER Slot + { + get => which == WHICH.Slot ? Rewrap<@slot.WRITER>() : default; + } + + public @group.WRITER Group + { + get => which == WHICH.Group ? Rewrap<@group.WRITER>() : default; + } + + public @ordinal.WRITER Ordinal + { + get => Rewrap<@ordinal.WRITER>(); + } + } + + public class @slot : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Offset = reader.Offset; + Type = CapnpSerializable.Create(reader.Type); + DefaultValue = CapnpSerializable.Create(reader.DefaultValue); + HadExplicitDefault = reader.HadExplicitDefault; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Offset = Offset; + Type?.serialize(writer.Type); + DefaultValue?.serialize(writer.DefaultValue); + writer.HadExplicitDefault = HadExplicitDefault; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Offset + { + get; + set; + } + + public Capnp.Schema.Type Type + { + get; + set; + } + + public Capnp.Schema.Value DefaultValue + { + get; + set; + } + + public bool HadExplicitDefault + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint Offset => ctx.ReadDataUInt(32UL, 0U); + public Capnp.Schema.Type.READER Type => ctx.ReadStruct(2, Capnp.Schema.Type.READER.create); + public Capnp.Schema.Value.READER DefaultValue => ctx.ReadStruct(3, Capnp.Schema.Value.READER.create); + public bool HadExplicitDefault => ctx.ReadDataBool(128UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public uint Offset + { + get => this.ReadDataUInt(32UL, 0U); + set => this.WriteData(32UL, value, 0U); + } + + public Capnp.Schema.Type.WRITER Type + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnp.Schema.Value.WRITER DefaultValue + { + get => BuildPointer(3); + set => Link(3, value); + } + + public bool HadExplicitDefault + { + get => this.ReadDataBool(128UL, false); + set => this.WriteData(128UL, value, false); + } + } + } + + public class @group : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TypeId = reader.TypeId; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TypeId = TypeId; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong TypeId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong TypeId => ctx.ReadDataULong(128UL, 0UL); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong TypeId + { + get => this.ReadDataULong(128UL, 0UL); + set => this.WriteData(128UL, value, 0UL); + } + } + } + + public class @ordinal : ICapnpSerializable + { + public enum WHICH : ushort + { + Implicit = 0, + Explicit = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Implicit: + which = reader.which; + break; + case WHICH.Explicit: + Explicit = reader.Explicit; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Implicit: + break; + case WHICH.Explicit: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Implicit: + break; + case WHICH.Explicit: + writer.Explicit = Explicit.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort? Explicit + { + get => _which == WHICH.Explicit ? (ushort? )_content : null; + set + { + _which = WHICH.Explicit; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(80U, (ushort)0); + public ushort Explicit => which == WHICH.Explicit ? ctx.ReadDataUShort(96UL, (ushort)0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(80U, (ushort)0); + set => this.WriteData(80U, (ushort)value, (ushort)0); + } + + public ushort Explicit + { + get => which == WHICH.Explicit ? this.ReadDataUShort(96UL, (ushort)0) : default; + set => this.WriteData(96UL, value, (ushort)0); + } + } + } + } + + public class Enumerant : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Name = reader.Name; + CodeOrder = reader.CodeOrder; + Annotations = reader.Annotations.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Name = Name; + writer.CodeOrder = CodeOrder; + writer.Annotations.Init(Annotations, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + get; + set; + } + + public ushort CodeOrder + { + get; + set; + } + + public IReadOnlyList Annotations + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Name => ctx.ReadText(0, ""); + public ushort CodeOrder => ctx.ReadDataUShort(0UL, (ushort)0); + public IReadOnlyList Annotations => ctx.ReadList(1).Cast(Capnp.Schema.Annotation.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ushort CodeOrder + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + + public ListOfStructsSerializer Annotations + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + public class Superclass : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + Brand = CapnpSerializable.Create(reader.Brand); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + Brand?.serialize(writer.Brand); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Id + { + get; + set; + } + + public Capnp.Schema.Brand Brand + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Id => ctx.ReadDataULong(0UL, 0UL); + public Capnp.Schema.Brand.READER Brand => ctx.ReadStruct(0, Capnp.Schema.Brand.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public ulong Id + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public Capnp.Schema.Brand.WRITER Brand + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class Method : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Name = reader.Name; + CodeOrder = reader.CodeOrder; + ParamStructType = reader.ParamStructType; + ResultStructType = reader.ResultStructType; + Annotations = reader.Annotations.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + ParamBrand = CapnpSerializable.Create(reader.ParamBrand); + ResultBrand = CapnpSerializable.Create(reader.ResultBrand); + ImplicitParameters = reader.ImplicitParameters.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Name = Name; + writer.CodeOrder = CodeOrder; + writer.ParamStructType = ParamStructType; + writer.ResultStructType = ResultStructType; + writer.Annotations.Init(Annotations, (_s1, _v1) => _v1?.serialize(_s1)); + ParamBrand?.serialize(writer.ParamBrand); + ResultBrand?.serialize(writer.ResultBrand); + writer.ImplicitParameters.Init(ImplicitParameters, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Name + { + get; + set; + } + + public ushort CodeOrder + { + get; + set; + } + + public ulong ParamStructType + { + get; + set; + } + + public ulong ResultStructType + { + get; + set; + } + + public IReadOnlyList Annotations + { + get; + set; + } + + public Capnp.Schema.Brand ParamBrand + { + get; + set; + } + + public Capnp.Schema.Brand ResultBrand + { + get; + set; + } + + public IReadOnlyList ImplicitParameters + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Name => ctx.ReadText(0, ""); + public ushort CodeOrder => ctx.ReadDataUShort(0UL, (ushort)0); + public ulong ParamStructType => ctx.ReadDataULong(64UL, 0UL); + public ulong ResultStructType => ctx.ReadDataULong(128UL, 0UL); + public IReadOnlyList Annotations => ctx.ReadList(1).Cast(Capnp.Schema.Annotation.READER.create); + public Capnp.Schema.Brand.READER ParamBrand => ctx.ReadStruct(2, Capnp.Schema.Brand.READER.create); + public Capnp.Schema.Brand.READER ResultBrand => ctx.ReadStruct(3, Capnp.Schema.Brand.READER.create); + public IReadOnlyList ImplicitParameters => ctx.ReadList(4).Cast(Capnp.Schema.Node.Parameter.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 5); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ushort CodeOrder + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + + public ulong ParamStructType + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public ulong ResultStructType + { + get => this.ReadDataULong(128UL, 0UL); + set => this.WriteData(128UL, value, 0UL); + } + + public ListOfStructsSerializer Annotations + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public Capnp.Schema.Brand.WRITER ParamBrand + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnp.Schema.Brand.WRITER ResultBrand + { + get => BuildPointer(3); + set => Link(3, value); + } + + public ListOfStructsSerializer ImplicitParameters + { + get => BuildPointer>(4); + set => Link(4, value); + } + } + } + + public class Type : ICapnpSerializable + { + public enum WHICH : ushort + { + Void = 0, + Bool = 1, + Int8 = 2, + Int16 = 3, + Int32 = 4, + Int64 = 5, + Uint8 = 6, + Uint16 = 7, + Uint32 = 8, + Uint64 = 9, + Float32 = 10, + Float64 = 11, + Text = 12, + Data = 13, + List = 14, + Enum = 15, + Struct = 16, + Interface = 17, + AnyPointer = 18, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Void: + which = reader.which; + break; + case WHICH.Bool: + which = reader.which; + break; + case WHICH.Int8: + which = reader.which; + break; + case WHICH.Int16: + which = reader.which; + break; + case WHICH.Int32: + which = reader.which; + break; + case WHICH.Int64: + which = reader.which; + break; + case WHICH.Uint8: + which = reader.which; + break; + case WHICH.Uint16: + which = reader.which; + break; + case WHICH.Uint32: + which = reader.which; + break; + case WHICH.Uint64: + which = reader.which; + break; + case WHICH.Float32: + which = reader.which; + break; + case WHICH.Float64: + which = reader.which; + break; + case WHICH.Text: + which = reader.which; + break; + case WHICH.Data: + which = reader.which; + break; + case WHICH.List: + List = CapnpSerializable.Create(reader.List); + break; + case WHICH.Enum: + Enum = CapnpSerializable.Create(reader.Enum); + break; + case WHICH.Struct: + Struct = CapnpSerializable.Create(reader.Struct); + break; + case WHICH.Interface: + Interface = CapnpSerializable.Create(reader.Interface); + break; + case WHICH.AnyPointer: + AnyPointer = CapnpSerializable.Create(reader.AnyPointer); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Void: + break; + case WHICH.Bool: + break; + case WHICH.Int8: + break; + case WHICH.Int16: + break; + case WHICH.Int32: + break; + case WHICH.Int64: + break; + case WHICH.Uint8: + break; + case WHICH.Uint16: + break; + case WHICH.Uint32: + break; + case WHICH.Uint64: + break; + case WHICH.Float32: + break; + case WHICH.Float64: + break; + case WHICH.Text: + break; + case WHICH.Data: + break; + case WHICH.List: + _content = null; + break; + case WHICH.Enum: + _content = null; + break; + case WHICH.Struct: + _content = null; + break; + case WHICH.Interface: + _content = null; + break; + case WHICH.AnyPointer: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Void: + break; + case WHICH.Bool: + break; + case WHICH.Int8: + break; + case WHICH.Int16: + break; + case WHICH.Int32: + break; + case WHICH.Int64: + break; + case WHICH.Uint8: + break; + case WHICH.Uint16: + break; + case WHICH.Uint32: + break; + case WHICH.Uint64: + break; + case WHICH.Float32: + break; + case WHICH.Float64: + break; + case WHICH.Text: + break; + case WHICH.Data: + break; + case WHICH.List: + List?.serialize(writer.List); + break; + case WHICH.Enum: + Enum?.serialize(writer.Enum); + break; + case WHICH.Struct: + Struct?.serialize(writer.Struct); + break; + case WHICH.Interface: + Interface?.serialize(writer.Interface); + break; + case WHICH.AnyPointer: + AnyPointer?.serialize(writer.AnyPointer); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Schema.Type.@list List + { + get => _which == WHICH.List ? (Capnp.Schema.Type.@list)_content : null; + set + { + _which = WHICH.List; + _content = value; + } + } + + public Capnp.Schema.Type.@enum Enum + { + get => _which == WHICH.Enum ? (Capnp.Schema.Type.@enum)_content : null; + set + { + _which = WHICH.Enum; + _content = value; + } + } + + public Capnp.Schema.Type.@struct Struct + { + get => _which == WHICH.Struct ? (Capnp.Schema.Type.@struct)_content : null; + set + { + _which = WHICH.Struct; + _content = value; + } + } + + public Capnp.Schema.Type.@interface Interface + { + get => _which == WHICH.Interface ? (Capnp.Schema.Type.@interface)_content : null; + set + { + _which = WHICH.Interface; + _content = value; + } + } + + public Capnp.Schema.Type.@anyPointer AnyPointer + { + get => _which == WHICH.AnyPointer ? (Capnp.Schema.Type.@anyPointer)_content : null; + set + { + _which = WHICH.AnyPointer; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public @list.READER List => which == WHICH.List ? new @list.READER(ctx) : default; + public @enum.READER Enum => which == WHICH.Enum ? new @enum.READER(ctx) : default; + public @struct.READER Struct => which == WHICH.Struct ? new @struct.READER(ctx) : default; + public @interface.READER Interface => which == WHICH.Interface ? new @interface.READER(ctx) : default; + public @anyPointer.READER AnyPointer => which == WHICH.AnyPointer ? new @anyPointer.READER(ctx) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public @list.WRITER List + { + get => which == WHICH.List ? Rewrap<@list.WRITER>() : default; + } + + public @enum.WRITER Enum + { + get => which == WHICH.Enum ? Rewrap<@enum.WRITER>() : default; + } + + public @struct.WRITER Struct + { + get => which == WHICH.Struct ? Rewrap<@struct.WRITER>() : default; + } + + public @interface.WRITER Interface + { + get => which == WHICH.Interface ? Rewrap<@interface.WRITER>() : default; + } + + public @anyPointer.WRITER AnyPointer + { + get => which == WHICH.AnyPointer ? Rewrap<@anyPointer.WRITER>() : default; + } + } + + public class @list : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + ElementType = CapnpSerializable.Create(reader.ElementType); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + ElementType?.serialize(writer.ElementType); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Schema.Type ElementType + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnp.Schema.Type.READER ElementType => ctx.ReadStruct(0, Capnp.Schema.Type.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public Capnp.Schema.Type.WRITER ElementType + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class @enum : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TypeId = reader.TypeId; + Brand = CapnpSerializable.Create(reader.Brand); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TypeId = TypeId; + Brand?.serialize(writer.Brand); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong TypeId + { + get; + set; + } + + public Capnp.Schema.Brand Brand + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong TypeId => ctx.ReadDataULong(64UL, 0UL); + public Capnp.Schema.Brand.READER Brand => ctx.ReadStruct(0, Capnp.Schema.Brand.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong TypeId + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public Capnp.Schema.Brand.WRITER Brand + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class @struct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TypeId = reader.TypeId; + Brand = CapnpSerializable.Create(reader.Brand); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TypeId = TypeId; + Brand?.serialize(writer.Brand); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong TypeId + { + get; + set; + } + + public Capnp.Schema.Brand Brand + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong TypeId => ctx.ReadDataULong(64UL, 0UL); + public Capnp.Schema.Brand.READER Brand => ctx.ReadStruct(0, Capnp.Schema.Brand.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong TypeId + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public Capnp.Schema.Brand.WRITER Brand + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class @interface : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TypeId = reader.TypeId; + Brand = CapnpSerializable.Create(reader.Brand); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TypeId = TypeId; + Brand?.serialize(writer.Brand); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong TypeId + { + get; + set; + } + + public Capnp.Schema.Brand Brand + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong TypeId => ctx.ReadDataULong(64UL, 0UL); + public Capnp.Schema.Brand.READER Brand => ctx.ReadStruct(0, Capnp.Schema.Brand.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong TypeId + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public Capnp.Schema.Brand.WRITER Brand + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class @anyPointer : ICapnpSerializable + { + public enum WHICH : ushort + { + Unconstrained = 0, + Parameter = 1, + ImplicitMethodParameter = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Unconstrained: + Unconstrained = CapnpSerializable.Create(reader.Unconstrained); + break; + case WHICH.Parameter: + Parameter = CapnpSerializable.Create(reader.Parameter); + break; + case WHICH.ImplicitMethodParameter: + ImplicitMethodParameter = CapnpSerializable.Create(reader.ImplicitMethodParameter); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Unconstrained: + _content = null; + break; + case WHICH.Parameter: + _content = null; + break; + case WHICH.ImplicitMethodParameter: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Unconstrained: + Unconstrained?.serialize(writer.Unconstrained); + break; + case WHICH.Parameter: + Parameter?.serialize(writer.Parameter); + break; + case WHICH.ImplicitMethodParameter: + ImplicitMethodParameter?.serialize(writer.ImplicitMethodParameter); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Schema.Type.@anyPointer.@unconstrained Unconstrained + { + get => _which == WHICH.Unconstrained ? (Capnp.Schema.Type.@anyPointer.@unconstrained)_content : null; + set + { + _which = WHICH.Unconstrained; + _content = value; + } + } + + public Capnp.Schema.Type.@anyPointer.@parameter Parameter + { + get => _which == WHICH.Parameter ? (Capnp.Schema.Type.@anyPointer.@parameter)_content : null; + set + { + _which = WHICH.Parameter; + _content = value; + } + } + + public Capnp.Schema.Type.@anyPointer.@implicitMethodParameter ImplicitMethodParameter + { + get => _which == WHICH.ImplicitMethodParameter ? (Capnp.Schema.Type.@anyPointer.@implicitMethodParameter)_content : null; + set + { + _which = WHICH.ImplicitMethodParameter; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(64U, (ushort)0); + public @unconstrained.READER Unconstrained => which == WHICH.Unconstrained ? new @unconstrained.READER(ctx) : default; + public @parameter.READER Parameter => which == WHICH.Parameter ? new @parameter.READER(ctx) : default; + public @implicitMethodParameter.READER ImplicitMethodParameter => which == WHICH.ImplicitMethodParameter ? new @implicitMethodParameter.READER(ctx) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(64U, (ushort)0); + set => this.WriteData(64U, (ushort)value, (ushort)0); + } + + public @unconstrained.WRITER Unconstrained + { + get => which == WHICH.Unconstrained ? Rewrap<@unconstrained.WRITER>() : default; + } + + public @parameter.WRITER Parameter + { + get => which == WHICH.Parameter ? Rewrap<@parameter.WRITER>() : default; + } + + public @implicitMethodParameter.WRITER ImplicitMethodParameter + { + get => which == WHICH.ImplicitMethodParameter ? Rewrap<@implicitMethodParameter.WRITER>() : default; + } + } + + public class @unconstrained : ICapnpSerializable + { + public enum WHICH : ushort + { + AnyKind = 0, + Struct = 1, + List = 2, + Capability = 3, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.AnyKind: + which = reader.which; + break; + case WHICH.Struct: + which = reader.which; + break; + case WHICH.List: + which = reader.which; + break; + case WHICH.Capability: + which = reader.which; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.AnyKind: + break; + case WHICH.Struct: + break; + case WHICH.List: + break; + case WHICH.Capability: + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.AnyKind: + break; + case WHICH.Struct: + break; + case WHICH.List: + break; + case WHICH.Capability: + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(80U, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(80U, (ushort)0); + set => this.WriteData(80U, (ushort)value, (ushort)0); + } + } + } + + public class @parameter : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + ScopeId = reader.ScopeId; + ParameterIndex = reader.ParameterIndex; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.ScopeId = ScopeId; + writer.ParameterIndex = ParameterIndex; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong ScopeId + { + get; + set; + } + + public ushort ParameterIndex + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong ScopeId => ctx.ReadDataULong(128UL, 0UL); + public ushort ParameterIndex => ctx.ReadDataUShort(80UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong ScopeId + { + get => this.ReadDataULong(128UL, 0UL); + set => this.WriteData(128UL, value, 0UL); + } + + public ushort ParameterIndex + { + get => this.ReadDataUShort(80UL, (ushort)0); + set => this.WriteData(80UL, value, (ushort)0); + } + } + } + + public class @implicitMethodParameter : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + ParameterIndex = reader.ParameterIndex; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.ParameterIndex = ParameterIndex; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort ParameterIndex + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ushort ParameterIndex => ctx.ReadDataUShort(80UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ushort ParameterIndex + { + get => this.ReadDataUShort(80UL, (ushort)0); + set => this.WriteData(80UL, value, (ushort)0); + } + } + } + } + } + + public class Brand : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Scopes = reader.Scopes.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Scopes.Init(Scopes, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Scopes + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList Scopes => ctx.ReadList(0).Cast(Capnp.Schema.Brand.Scope.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public ListOfStructsSerializer Scopes + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + + public class Scope : ICapnpSerializable + { + public enum WHICH : ushort + { + Bind = 0, + Inherit = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Bind: + Bind = reader.Bind.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + break; + case WHICH.Inherit: + which = reader.which; + break; + } + + ScopeId = reader.ScopeId; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Bind: + _content = null; + break; + case WHICH.Inherit: + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Bind: + writer.Bind.Init(Bind, (_s1, _v1) => _v1?.serialize(_s1)); + break; + case WHICH.Inherit: + break; + } + + writer.ScopeId = ScopeId; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong ScopeId + { + get; + set; + } + + public IReadOnlyList Bind + { + get => _which == WHICH.Bind ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Bind; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(64U, (ushort)0); + public ulong ScopeId => ctx.ReadDataULong(0UL, 0UL); + public IReadOnlyList Bind => which == WHICH.Bind ? ctx.ReadList(0).Cast(Capnp.Schema.Brand.Binding.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(64U, (ushort)0); + set => this.WriteData(64U, (ushort)value, (ushort)0); + } + + public ulong ScopeId + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public ListOfStructsSerializer Bind + { + get => which == WHICH.Bind ? BuildPointer>(0) : default; + set => Link(0, value); + } + } + } + + public class Binding : ICapnpSerializable + { + public enum WHICH : ushort + { + Unbound = 0, + Type = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Unbound: + which = reader.which; + break; + case WHICH.Type: + Type = CapnpSerializable.Create(reader.Type); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Unbound: + break; + case WHICH.Type: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Unbound: + break; + case WHICH.Type: + Type?.serialize(writer.Type); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnp.Schema.Type Type + { + get => _which == WHICH.Type ? (Capnp.Schema.Type)_content : null; + set + { + _which = WHICH.Type; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public Capnp.Schema.Type.READER Type => which == WHICH.Type ? ctx.ReadStruct(0, Capnp.Schema.Type.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public Capnp.Schema.Type.WRITER Type + { + get => which == WHICH.Type ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + } + + public class Value : ICapnpSerializable + { + public enum WHICH : ushort + { + Void = 0, + Bool = 1, + Int8 = 2, + Int16 = 3, + Int32 = 4, + Int64 = 5, + Uint8 = 6, + Uint16 = 7, + Uint32 = 8, + Uint64 = 9, + Float32 = 10, + Float64 = 11, + Text = 12, + Data = 13, + List = 14, + Enum = 15, + Struct = 16, + Interface = 17, + AnyPointer = 18, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Void: + which = reader.which; + break; + case WHICH.Bool: + Bool = reader.Bool; + break; + case WHICH.Int8: + Int8 = reader.Int8; + break; + case WHICH.Int16: + Int16 = reader.Int16; + break; + case WHICH.Int32: + Int32 = reader.Int32; + break; + case WHICH.Int64: + Int64 = reader.Int64; + break; + case WHICH.Uint8: + Uint8 = reader.Uint8; + break; + case WHICH.Uint16: + Uint16 = reader.Uint16; + break; + case WHICH.Uint32: + Uint32 = reader.Uint32; + break; + case WHICH.Uint64: + Uint64 = reader.Uint64; + break; + case WHICH.Float32: + Float32 = reader.Float32; + break; + case WHICH.Float64: + Float64 = reader.Float64; + break; + case WHICH.Text: + Text = reader.Text; + break; + case WHICH.Data: + Data = reader.Data; + break; + case WHICH.List: + List = CapnpSerializable.Create(reader.List); + break; + case WHICH.Enum: + Enum = reader.Enum; + break; + case WHICH.Struct: + Struct = CapnpSerializable.Create(reader.Struct); + break; + case WHICH.Interface: + which = reader.which; + break; + case WHICH.AnyPointer: + AnyPointer = CapnpSerializable.Create(reader.AnyPointer); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Void: + break; + case WHICH.Bool: + _content = false; + break; + case WHICH.Int8: + _content = 0; + break; + case WHICH.Int16: + _content = 0; + break; + case WHICH.Int32: + _content = 0; + break; + case WHICH.Int64: + _content = 0; + break; + case WHICH.Uint8: + _content = 0; + break; + case WHICH.Uint16: + _content = 0; + break; + case WHICH.Uint32: + _content = 0; + break; + case WHICH.Uint64: + _content = 0; + break; + case WHICH.Float32: + _content = 0F; + break; + case WHICH.Float64: + _content = 0; + break; + case WHICH.Text: + _content = null; + break; + case WHICH.Data: + _content = null; + break; + case WHICH.List: + _content = null; + break; + case WHICH.Enum: + _content = 0; + break; + case WHICH.Struct: + _content = null; + break; + case WHICH.Interface: + break; + case WHICH.AnyPointer: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Void: + break; + case WHICH.Bool: + writer.Bool = Bool.Value; + break; + case WHICH.Int8: + writer.Int8 = Int8.Value; + break; + case WHICH.Int16: + writer.Int16 = Int16.Value; + break; + case WHICH.Int32: + writer.Int32 = Int32.Value; + break; + case WHICH.Int64: + writer.Int64 = Int64.Value; + break; + case WHICH.Uint8: + writer.Uint8 = Uint8.Value; + break; + case WHICH.Uint16: + writer.Uint16 = Uint16.Value; + break; + case WHICH.Uint32: + writer.Uint32 = Uint32.Value; + break; + case WHICH.Uint64: + writer.Uint64 = Uint64.Value; + break; + case WHICH.Float32: + writer.Float32 = Float32.Value; + break; + case WHICH.Float64: + writer.Float64 = Float64.Value; + break; + case WHICH.Text: + writer.Text = Text; + break; + case WHICH.Data: + writer.Data.Init(Data); + break; + case WHICH.List: + writer.List.SetObject(List); + break; + case WHICH.Enum: + writer.Enum = Enum.Value; + break; + case WHICH.Struct: + writer.Struct.SetObject(Struct); + break; + case WHICH.Interface: + break; + case WHICH.AnyPointer: + writer.AnyPointer.SetObject(AnyPointer); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? Bool + { + get => _which == WHICH.Bool ? (bool? )_content : null; + set + { + _which = WHICH.Bool; + _content = value; + } + } + + public sbyte? Int8 + { + get => _which == WHICH.Int8 ? (sbyte? )_content : null; + set + { + _which = WHICH.Int8; + _content = value; + } + } + + public short? Int16 + { + get => _which == WHICH.Int16 ? (short? )_content : null; + set + { + _which = WHICH.Int16; + _content = value; + } + } + + public int? Int32 + { + get => _which == WHICH.Int32 ? (int? )_content : null; + set + { + _which = WHICH.Int32; + _content = value; + } + } + + public long? Int64 + { + get => _which == WHICH.Int64 ? (long? )_content : null; + set + { + _which = WHICH.Int64; + _content = value; + } + } + + public byte? Uint8 + { + get => _which == WHICH.Uint8 ? (byte? )_content : null; + set + { + _which = WHICH.Uint8; + _content = value; + } + } + + public ushort? Uint16 + { + get => _which == WHICH.Uint16 ? (ushort? )_content : null; + set + { + _which = WHICH.Uint16; + _content = value; + } + } + + public uint? Uint32 + { + get => _which == WHICH.Uint32 ? (uint? )_content : null; + set + { + _which = WHICH.Uint32; + _content = value; + } + } + + public ulong? Uint64 + { + get => _which == WHICH.Uint64 ? (ulong? )_content : null; + set + { + _which = WHICH.Uint64; + _content = value; + } + } + + public float? Float32 + { + get => _which == WHICH.Float32 ? (float? )_content : null; + set + { + _which = WHICH.Float32; + _content = value; + } + } + + public double? Float64 + { + get => _which == WHICH.Float64 ? (double? )_content : null; + set + { + _which = WHICH.Float64; + _content = value; + } + } + + public string Text + { + get => _which == WHICH.Text ? (string)_content : null; + set + { + _which = WHICH.Text; + _content = value; + } + } + + public IReadOnlyList Data + { + get => _which == WHICH.Data ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Data; + _content = value; + } + } + + public AnyPointer List + { + get => _which == WHICH.List ? (AnyPointer)_content : null; + set + { + _which = WHICH.List; + _content = value; + } + } + + public ushort? Enum + { + get => _which == WHICH.Enum ? (ushort? )_content : null; + set + { + _which = WHICH.Enum; + _content = value; + } + } + + public AnyPointer Struct + { + get => _which == WHICH.Struct ? (AnyPointer)_content : null; + set + { + _which = WHICH.Struct; + _content = value; + } + } + + public AnyPointer AnyPointer + { + get => _which == WHICH.AnyPointer ? (AnyPointer)_content : null; + set + { + _which = WHICH.AnyPointer; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public bool Bool => which == WHICH.Bool ? ctx.ReadDataBool(16UL, false) : default; + public sbyte Int8 => which == WHICH.Int8 ? ctx.ReadDataSByte(16UL, (sbyte)0) : default; + public short Int16 => which == WHICH.Int16 ? ctx.ReadDataShort(16UL, (short)0) : default; + public int Int32 => which == WHICH.Int32 ? ctx.ReadDataInt(32UL, 0) : default; + public long Int64 => which == WHICH.Int64 ? ctx.ReadDataLong(64UL, 0L) : default; + public byte Uint8 => which == WHICH.Uint8 ? ctx.ReadDataByte(16UL, (byte)0) : default; + public ushort Uint16 => which == WHICH.Uint16 ? ctx.ReadDataUShort(16UL, (ushort)0) : default; + public uint Uint32 => which == WHICH.Uint32 ? ctx.ReadDataUInt(32UL, 0U) : default; + public ulong Uint64 => which == WHICH.Uint64 ? ctx.ReadDataULong(64UL, 0UL) : default; + public float Float32 => which == WHICH.Float32 ? ctx.ReadDataFloat(32UL, 0F) : default; + public double Float64 => which == WHICH.Float64 ? ctx.ReadDataDouble(64UL, 0) : default; + public string Text => which == WHICH.Text ? ctx.ReadText(0, "") : default; + public IReadOnlyList Data => which == WHICH.Data ? ctx.ReadList(0).CastByte() : default; + public DeserializerState List => which == WHICH.List ? ctx.StructReadPointer(0) : default; + public ushort Enum => which == WHICH.Enum ? ctx.ReadDataUShort(16UL, (ushort)0) : default; + public DeserializerState Struct => which == WHICH.Struct ? ctx.StructReadPointer(0) : default; + public DeserializerState AnyPointer => which == WHICH.AnyPointer ? ctx.StructReadPointer(0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public bool Bool + { + get => which == WHICH.Bool ? this.ReadDataBool(16UL, false) : default; + set => this.WriteData(16UL, value, false); + } + + public sbyte Int8 + { + get => which == WHICH.Int8 ? this.ReadDataSByte(16UL, (sbyte)0) : default; + set => this.WriteData(16UL, value, (sbyte)0); + } + + public short Int16 + { + get => which == WHICH.Int16 ? this.ReadDataShort(16UL, (short)0) : default; + set => this.WriteData(16UL, value, (short)0); + } + + public int Int32 + { + get => which == WHICH.Int32 ? this.ReadDataInt(32UL, 0) : default; + set => this.WriteData(32UL, value, 0); + } + + public long Int64 + { + get => which == WHICH.Int64 ? this.ReadDataLong(64UL, 0L) : default; + set => this.WriteData(64UL, value, 0L); + } + + public byte Uint8 + { + get => which == WHICH.Uint8 ? this.ReadDataByte(16UL, (byte)0) : default; + set => this.WriteData(16UL, value, (byte)0); + } + + public ushort Uint16 + { + get => which == WHICH.Uint16 ? this.ReadDataUShort(16UL, (ushort)0) : default; + set => this.WriteData(16UL, value, (ushort)0); + } + + public uint Uint32 + { + get => which == WHICH.Uint32 ? this.ReadDataUInt(32UL, 0U) : default; + set => this.WriteData(32UL, value, 0U); + } + + public ulong Uint64 + { + get => which == WHICH.Uint64 ? this.ReadDataULong(64UL, 0UL) : default; + set => this.WriteData(64UL, value, 0UL); + } + + public float Float32 + { + get => which == WHICH.Float32 ? this.ReadDataFloat(32UL, 0F) : default; + set => this.WriteData(32UL, value, 0F); + } + + public double Float64 + { + get => which == WHICH.Float64 ? this.ReadDataDouble(64UL, 0) : default; + set => this.WriteData(64UL, value, 0); + } + + public string Text + { + get => which == WHICH.Text ? this.ReadText(0, "") : default; + set => this.WriteText(0, value, ""); + } + + public ListOfPrimitivesSerializer Data + { + get => which == WHICH.Data ? BuildPointer>(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState List + { + get => which == WHICH.List ? BuildPointer(0) : default; + set => Link(0, value); + } + + public ushort Enum + { + get => which == WHICH.Enum ? this.ReadDataUShort(16UL, (ushort)0) : default; + set => this.WriteData(16UL, value, (ushort)0); + } + + public DynamicSerializerState Struct + { + get => which == WHICH.Struct ? BuildPointer(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState AnyPointer + { + get => which == WHICH.AnyPointer ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class Annotation : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + Value = CapnpSerializable.Create(reader.Value); + Brand = CapnpSerializable.Create(reader.Brand); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + Value?.serialize(writer.Value); + Brand?.serialize(writer.Brand); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Id + { + get; + set; + } + + public Capnp.Schema.Value Value + { + get; + set; + } + + public Capnp.Schema.Brand Brand + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Id => ctx.ReadDataULong(0UL, 0UL); + public Capnp.Schema.Value.READER Value => ctx.ReadStruct(0, Capnp.Schema.Value.READER.create); + public Capnp.Schema.Brand.READER Brand => ctx.ReadStruct(1, Capnp.Schema.Brand.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public ulong Id + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public Capnp.Schema.Value.WRITER Value + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnp.Schema.Brand.WRITER Brand + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public enum ElementSize : ushort + { + empty, + bit, + @byte, + twoBytes, + fourBytes, + eightBytes, + pointer, + inlineComposite + } + + public class CapnpVersion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Major = reader.Major; + Minor = reader.Minor; + Micro = reader.Micro; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Major = Major; + writer.Minor = Minor; + writer.Micro = Micro; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort Major + { + get; + set; + } + + public byte Minor + { + get; + set; + } + + public byte Micro + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ushort Major => ctx.ReadDataUShort(0UL, (ushort)0); + public byte Minor => ctx.ReadDataByte(16UL, (byte)0); + public byte Micro => ctx.ReadDataByte(24UL, (byte)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public ushort Major + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + + public byte Minor + { + get => this.ReadDataByte(16UL, (byte)0); + set => this.WriteData(16UL, value, (byte)0); + } + + public byte Micro + { + get => this.ReadDataByte(24UL, (byte)0); + set => this.WriteData(24UL, value, (byte)0); + } + } + } + + public class CodeGeneratorRequest : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Nodes = reader.Nodes.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + RequestedFiles = reader.RequestedFiles.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + CapnpVersion = CapnpSerializable.Create(reader.CapnpVersion); + SourceInfo = reader.SourceInfo.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Nodes.Init(Nodes, (_s1, _v1) => _v1?.serialize(_s1)); + writer.RequestedFiles.Init(RequestedFiles, (_s1, _v1) => _v1?.serialize(_s1)); + CapnpVersion?.serialize(writer.CapnpVersion); + writer.SourceInfo.Init(SourceInfo, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList Nodes + { + get; + set; + } + + public IReadOnlyList RequestedFiles + { + get; + set; + } + + public Capnp.Schema.CapnpVersion CapnpVersion + { + get; + set; + } + + public IReadOnlyList SourceInfo + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList Nodes => ctx.ReadList(0).Cast(Capnp.Schema.Node.READER.create); + public IReadOnlyList RequestedFiles => ctx.ReadList(1).Cast(Capnp.Schema.CodeGeneratorRequest.RequestedFile.READER.create); + public Capnp.Schema.CapnpVersion.READER CapnpVersion => ctx.ReadStruct(2, Capnp.Schema.CapnpVersion.READER.create); + public IReadOnlyList SourceInfo => ctx.ReadList(3).Cast(Capnp.Schema.Node.SourceInfo.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public ListOfStructsSerializer Nodes + { + get => BuildPointer>(0); + set => Link(0, value); + } + + public ListOfStructsSerializer RequestedFiles + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public Capnp.Schema.CapnpVersion.WRITER CapnpVersion + { + get => BuildPointer(2); + set => Link(2, value); + } + + public ListOfStructsSerializer SourceInfo + { + get => BuildPointer>(3); + set => Link(3, value); + } + } + + public class RequestedFile : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + Filename = reader.Filename; + Imports = reader.Imports.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + writer.Filename = Filename; + writer.Imports.Init(Imports, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Id + { + get; + set; + } + + public string Filename + { + get; + set; + } + + public IReadOnlyList Imports + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Id => ctx.ReadDataULong(0UL, 0UL); + public string Filename => ctx.ReadText(0, ""); + public IReadOnlyList Imports => ctx.ReadList(1).Cast(Capnp.Schema.CodeGeneratorRequest.RequestedFile.Import.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public ulong Id + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public string Filename + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ListOfStructsSerializer Imports + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + + public class Import : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Id = reader.Id; + Name = reader.Name; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Id = Id; + writer.Name = Name; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Id + { + get; + set; + } + + public string Name + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Id => ctx.ReadDataULong(0UL, 0UL); + public string Name => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public ulong Id + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public string Name + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + } + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/test-import.capnp.cs b/MsBuildGenerationTest/capnp/test-import.capnp.cs new file mode 100644 index 0000000..3fc5b54 --- /dev/null +++ b/MsBuildGenerationTest/capnp/test-import.capnp.cs @@ -0,0 +1,67 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace CapnpGen +{ + public class TestImport : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Field = CapnpSerializable.Create(reader.Field); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Field?.serialize(writer.Field); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestAllTypes Field + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestAllTypes.READER Field => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER Field + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/test-import2.capnp.cs b/MsBuildGenerationTest/capnp/test-import2.capnp.cs new file mode 100644 index 0000000..534bba9 --- /dev/null +++ b/MsBuildGenerationTest/capnp/test-import2.capnp.cs @@ -0,0 +1,97 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace CapnpGen +{ + public class TestImport2 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + Baz = CapnpSerializable.Create(reader.Baz); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Foo?.serialize(writer.Foo); + Bar?.serialize(writer.Bar); + Baz?.serialize(writer.Baz); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestAllTypes Foo + { + get; + set; + } + + public Capnp.Schema.Node Bar + { + get; + set; + } + + public CapnpGen.TestImport Baz + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestAllTypes.READER Foo => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public Capnp.Schema.Node.READER Bar => ctx.ReadStruct(1, Capnp.Schema.Node.READER.create); + public CapnpGen.TestImport.READER Baz => ctx.ReadStruct(2, CapnpGen.TestImport.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 3); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnp.Schema.Node.WRITER Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + + public CapnpGen.TestImport.WRITER Baz + { + get => BuildPointer(2); + set => Link(2, value); + } + } + } +} \ No newline at end of file diff --git a/MsBuildGenerationTest/capnp/test.capnp.cs b/MsBuildGenerationTest/capnp/test.capnp.cs new file mode 100644 index 0000000..d20da0b --- /dev/null +++ b/MsBuildGenerationTest/capnp/test.capnp.cs @@ -0,0 +1,16200 @@ +using Capnp; +using Capnp.Rpc; +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace Capnproto_test.Capnp.Test +{ + public enum TestEnum : ushort + { + foo, + bar, + baz, + qux, + quux, + corge, + grault, + garply + } + + public class TestAllTypes : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BoolField = reader.BoolField; + Int8Field = reader.Int8Field; + Int16Field = reader.Int16Field; + Int32Field = reader.Int32Field; + Int64Field = reader.Int64Field; + UInt8Field = reader.UInt8Field; + UInt16Field = reader.UInt16Field; + UInt32Field = reader.UInt32Field; + UInt64Field = reader.UInt64Field; + Float32Field = reader.Float32Field; + Float64Field = reader.Float64Field; + TextField = reader.TextField; + DataField = reader.DataField; + StructField = CapnpSerializable.Create(reader.StructField); + EnumField = reader.EnumField; + VoidList = reader.VoidList; + BoolList = reader.BoolList; + Int8List = reader.Int8List; + Int16List = reader.Int16List; + Int32List = reader.Int32List; + Int64List = reader.Int64List; + UInt8List = reader.UInt8List; + UInt16List = reader.UInt16List; + UInt32List = reader.UInt32List; + UInt64List = reader.UInt64List; + Float32List = reader.Float32List; + Float64List = reader.Float64List; + TextList = reader.TextList; + DataList = reader.DataList; + StructList = reader.StructList.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + EnumList = reader.EnumList; + InterfaceList = reader.InterfaceList; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BoolField = BoolField; + writer.Int8Field = Int8Field; + writer.Int16Field = Int16Field; + writer.Int32Field = Int32Field; + writer.Int64Field = Int64Field; + writer.UInt8Field = UInt8Field; + writer.UInt16Field = UInt16Field; + writer.UInt32Field = UInt32Field; + writer.UInt64Field = UInt64Field; + writer.Float32Field = Float32Field; + writer.Float64Field = Float64Field; + writer.TextField = TextField; + writer.DataField.Init(DataField); + StructField?.serialize(writer.StructField); + writer.EnumField = EnumField; + writer.VoidList.Init(VoidList); + writer.BoolList.Init(BoolList); + writer.Int8List.Init(Int8List); + writer.Int16List.Init(Int16List); + writer.Int32List.Init(Int32List); + writer.Int64List.Init(Int64List); + writer.UInt8List.Init(UInt8List); + writer.UInt16List.Init(UInt16List); + writer.UInt32List.Init(UInt32List); + writer.UInt64List.Init(UInt64List); + writer.Float32List.Init(Float32List); + writer.Float64List.Init(Float64List); + writer.TextList.Init(TextList); + writer.DataList.Init(DataList, (_s1, _v1) => _s1.Init(_v1)); + writer.StructList.Init(StructList, (_s1, _v1) => _v1?.serialize(_s1)); + writer.EnumList.Init(EnumList); + writer.InterfaceList.Init(InterfaceList); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool BoolField + { + get; + set; + } + + public sbyte Int8Field + { + get; + set; + } + + public short Int16Field + { + get; + set; + } + + public int Int32Field + { + get; + set; + } + + public long Int64Field + { + get; + set; + } + + public byte UInt8Field + { + get; + set; + } + + public ushort UInt16Field + { + get; + set; + } + + public uint UInt32Field + { + get; + set; + } + + public ulong UInt64Field + { + get; + set; + } + + public float Float32Field + { + get; + set; + } + + public double Float64Field + { + get; + set; + } + + public string TextField + { + get; + set; + } + + public IReadOnlyList DataField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestAllTypes StructField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get; + set; + } + + public int VoidList + { + get; + set; + } + + public IReadOnlyList BoolList + { + get; + set; + } + + public IReadOnlyList Int8List + { + get; + set; + } + + public IReadOnlyList Int16List + { + get; + set; + } + + public IReadOnlyList Int32List + { + get; + set; + } + + public IReadOnlyList Int64List + { + get; + set; + } + + public IReadOnlyList UInt8List + { + get; + set; + } + + public IReadOnlyList UInt16List + { + get; + set; + } + + public IReadOnlyList UInt32List + { + get; + set; + } + + public IReadOnlyList UInt64List + { + get; + set; + } + + public IReadOnlyList Float32List + { + get; + set; + } + + public IReadOnlyList Float64List + { + get; + set; + } + + public IReadOnlyList TextList + { + get; + set; + } + + public IReadOnlyList> DataList + { + get; + set; + } + + public IReadOnlyList StructList + { + get; + set; + } + + public IReadOnlyList EnumList + { + get; + set; + } + + public int InterfaceList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool BoolField => ctx.ReadDataBool(0UL, false); + public sbyte Int8Field => ctx.ReadDataSByte(8UL, (sbyte)0); + public short Int16Field => ctx.ReadDataShort(16UL, (short)0); + public int Int32Field => ctx.ReadDataInt(32UL, 0); + public long Int64Field => ctx.ReadDataLong(64UL, 0L); + public byte UInt8Field => ctx.ReadDataByte(128UL, (byte)0); + public ushort UInt16Field => ctx.ReadDataUShort(144UL, (ushort)0); + public uint UInt32Field => ctx.ReadDataUInt(160UL, 0U); + public ulong UInt64Field => ctx.ReadDataULong(192UL, 0UL); + public float Float32Field => ctx.ReadDataFloat(256UL, 0F); + public double Float64Field => ctx.ReadDataDouble(320UL, 0); + public string TextField => ctx.ReadText(0, ""); + public IReadOnlyList DataField => ctx.ReadList(1).CastByte(); + public Capnproto_test.Capnp.Test.TestAllTypes.READER StructField => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public Capnproto_test.Capnp.Test.TestEnum EnumField => (Capnproto_test.Capnp.Test.TestEnum)ctx.ReadDataUShort(288UL, (ushort)0); + public int VoidList => ctx.ReadList(3).Count; + public IReadOnlyList BoolList => ctx.ReadList(4).CastBool(); + public IReadOnlyList Int8List => ctx.ReadList(5).CastSByte(); + public IReadOnlyList Int16List => ctx.ReadList(6).CastShort(); + public IReadOnlyList Int32List => ctx.ReadList(7).CastInt(); + public IReadOnlyList Int64List => ctx.ReadList(8).CastLong(); + public IReadOnlyList UInt8List => ctx.ReadList(9).CastByte(); + public IReadOnlyList UInt16List => ctx.ReadList(10).CastUShort(); + public IReadOnlyList UInt32List => ctx.ReadList(11).CastUInt(); + public IReadOnlyList UInt64List => ctx.ReadList(12).CastULong(); + public IReadOnlyList Float32List => ctx.ReadList(13).CastFloat(); + public IReadOnlyList Float64List => ctx.ReadList(14).CastDouble(); + public IReadOnlyList TextList => ctx.ReadList(15).CastText2(); + public IReadOnlyList> DataList => ctx.ReadList(16).CastData(); + public IReadOnlyList StructList => ctx.ReadList(17).Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public IReadOnlyList EnumList => ctx.ReadList(18).CastEnums(_0 => (Capnproto_test.Capnp.Test.TestEnum)_0); + public int InterfaceList => ctx.ReadList(19).Count; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(6, 20); + } + + public bool BoolField + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public sbyte Int8Field + { + get => this.ReadDataSByte(8UL, (sbyte)0); + set => this.WriteData(8UL, value, (sbyte)0); + } + + public short Int16Field + { + get => this.ReadDataShort(16UL, (short)0); + set => this.WriteData(16UL, value, (short)0); + } + + public int Int32Field + { + get => this.ReadDataInt(32UL, 0); + set => this.WriteData(32UL, value, 0); + } + + public long Int64Field + { + get => this.ReadDataLong(64UL, 0L); + set => this.WriteData(64UL, value, 0L); + } + + public byte UInt8Field + { + get => this.ReadDataByte(128UL, (byte)0); + set => this.WriteData(128UL, value, (byte)0); + } + + public ushort UInt16Field + { + get => this.ReadDataUShort(144UL, (ushort)0); + set => this.WriteData(144UL, value, (ushort)0); + } + + public uint UInt32Field + { + get => this.ReadDataUInt(160UL, 0U); + set => this.WriteData(160UL, value, 0U); + } + + public ulong UInt64Field + { + get => this.ReadDataULong(192UL, 0UL); + set => this.WriteData(192UL, value, 0UL); + } + + public float Float32Field + { + get => this.ReadDataFloat(256UL, 0F); + set => this.WriteData(256UL, value, 0F); + } + + public double Float64Field + { + get => this.ReadDataDouble(320UL, 0); + set => this.WriteData(320UL, value, 0); + } + + public string TextField + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ListOfPrimitivesSerializer DataField + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER StructField + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get => (Capnproto_test.Capnp.Test.TestEnum)this.ReadDataUShort(288UL, (ushort)0); + set => this.WriteData(288UL, (ushort)value, (ushort)0); + } + + public ListOfEmptySerializer VoidList + { + get => BuildPointer(3); + set => Link(3, value); + } + + public ListOfBitsSerializer BoolList + { + get => BuildPointer(4); + set => Link(4, value); + } + + public ListOfPrimitivesSerializer Int8List + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public ListOfPrimitivesSerializer Int16List + { + get => BuildPointer>(6); + set => Link(6, value); + } + + public ListOfPrimitivesSerializer Int32List + { + get => BuildPointer>(7); + set => Link(7, value); + } + + public ListOfPrimitivesSerializer Int64List + { + get => BuildPointer>(8); + set => Link(8, value); + } + + public ListOfPrimitivesSerializer UInt8List + { + get => BuildPointer>(9); + set => Link(9, value); + } + + public ListOfPrimitivesSerializer UInt16List + { + get => BuildPointer>(10); + set => Link(10, value); + } + + public ListOfPrimitivesSerializer UInt32List + { + get => BuildPointer>(11); + set => Link(11, value); + } + + public ListOfPrimitivesSerializer UInt64List + { + get => BuildPointer>(12); + set => Link(12, value); + } + + public ListOfPrimitivesSerializer Float32List + { + get => BuildPointer>(13); + set => Link(13, value); + } + + public ListOfPrimitivesSerializer Float64List + { + get => BuildPointer>(14); + set => Link(14, value); + } + + public ListOfTextSerializer TextList + { + get => BuildPointer(15); + set => Link(15, value); + } + + public ListOfPointersSerializer> DataList + { + get => BuildPointer>>(16); + set => Link(16, value); + } + + public ListOfStructsSerializer StructList + { + get => BuildPointer>(17); + set => Link(17, value); + } + + public ListOfPrimitivesSerializer EnumList + { + get => BuildPointer>(18); + set => Link(18, value); + } + + public ListOfEmptySerializer InterfaceList + { + get => BuildPointer(19); + set => Link(19, value); + } + } + } + + public class TestDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BoolField = reader.BoolField; + Int8Field = reader.Int8Field; + Int16Field = reader.Int16Field; + Int32Field = reader.Int32Field; + Int64Field = reader.Int64Field; + UInt8Field = reader.UInt8Field; + UInt16Field = reader.UInt16Field; + UInt32Field = reader.UInt32Field; + UInt64Field = reader.UInt64Field; + Float32Field = reader.Float32Field; + Float64Field = reader.Float64Field; + TextField = reader.TextField; + DataField = reader.DataField; + StructField = CapnpSerializable.Create(reader.StructField); + EnumField = reader.EnumField; + VoidList = reader.VoidList; + BoolList = reader.BoolList; + Int8List = reader.Int8List; + Int16List = reader.Int16List; + Int32List = reader.Int32List; + Int64List = reader.Int64List; + UInt8List = reader.UInt8List; + UInt16List = reader.UInt16List; + UInt32List = reader.UInt32List; + UInt64List = reader.UInt64List; + Float32List = reader.Float32List; + Float64List = reader.Float64List; + TextList = reader.TextList; + DataList = reader.DataList; + StructList = reader.StructList.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + EnumList = reader.EnumList; + InterfaceList = reader.InterfaceList; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BoolField = BoolField; + writer.Int8Field = Int8Field; + writer.Int16Field = Int16Field; + writer.Int32Field = Int32Field; + writer.Int64Field = Int64Field; + writer.UInt8Field = UInt8Field; + writer.UInt16Field = UInt16Field; + writer.UInt32Field = UInt32Field; + writer.UInt64Field = UInt64Field; + writer.Float32Field = Float32Field; + writer.Float64Field = Float64Field; + writer.TextField = TextField; + writer.DataField.Init(DataField); + StructField?.serialize(writer.StructField); + writer.EnumField = EnumField; + writer.VoidList.Init(VoidList); + writer.BoolList.Init(BoolList); + writer.Int8List.Init(Int8List); + writer.Int16List.Init(Int16List); + writer.Int32List.Init(Int32List); + writer.Int64List.Init(Int64List); + writer.UInt8List.Init(UInt8List); + writer.UInt16List.Init(UInt16List); + writer.UInt32List.Init(UInt32List); + writer.UInt64List.Init(UInt64List); + writer.Float32List.Init(Float32List); + writer.Float64List.Init(Float64List); + writer.TextList.Init(TextList); + writer.DataList.Init(DataList, (_s1, _v1) => _s1.Init(_v1)); + writer.StructList.Init(StructList, (_s1, _v1) => _v1?.serialize(_s1)); + writer.EnumList.Init(EnumList); + writer.InterfaceList.Init(InterfaceList); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + TextField = TextField ?? "foo"; + DataField = DataField ?? new byte[]{98, 97, 114}; + StructField = StructField ?? new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = true, Int8Field = -12, Int16Field = 3456, Int32Field = -78901234, Int64Field = 56789012345678L, UInt8Field = 90, UInt16Field = 1234, UInt32Field = 56789012U, UInt64Field = 345678901234567890UL, Float32Field = -1.25E-10F, Float64Field = 345, TextField = "baz", DataField = new byte[]{113, 117, 120}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "nested", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "really nested", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 3, BoolList = new bool[]{false, true, false, true, true}, Int8List = new sbyte[]{12, -34, -128, 127}, Int16List = new short[]{1234, -5678, -32768, 32767}, Int32List = new int[]{12345678, -90123456, -2147483648, 2147483647}, Int64List = new long[]{123456789012345L, -678901234567890L, -9223372036854775808L, 9223372036854775807L}, UInt8List = new byte[]{12, 34, 0, 255}, UInt16List = new ushort[]{1234, 5678, 0, 65535}, UInt32List = new uint[]{12345678U, 90123456U, 0U, 4294967295U}, UInt64List = new ulong[]{123456789012345UL, 678901234567890UL, 0UL, 18446744073709551615UL}, Float32List = new float[]{0F, 1234567F, 1E+37F, -1E+37F, 1E-37F, -1E-37F}, Float64List = new double[]{0, 123456789012345, 1E+306, -1E+306, 1E-306, -1E-306}, TextList = new string[]{"quux", "corge", "grault"}, DataList = new IReadOnlyList[]{new byte[]{103, 97, 114, 112, 108, 121}, new byte[]{119, 97, 108, 100, 111}, new byte[]{102, 114, 101, 100}}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "x structlist 1", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "x structlist 2", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "x structlist 3", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{Capnproto_test.Capnp.Test.TestEnum.qux, Capnproto_test.Capnp.Test.TestEnum.bar, Capnproto_test.Capnp.Test.TestEnum.grault}, InterfaceList = 0}; + BoolList = BoolList ?? new bool[]{true, false, false, true}; + Int8List = Int8List ?? new sbyte[]{111, -111}; + Int16List = Int16List ?? new short[]{11111, -11111}; + Int32List = Int32List ?? new int[]{111111111, -111111111}; + Int64List = Int64List ?? new long[]{1111111111111111111L, -1111111111111111111L}; + UInt8List = UInt8List ?? new byte[]{111, 222}; + UInt16List = UInt16List ?? new ushort[]{33333, 44444}; + UInt32List = UInt32List ?? new uint[]{3333333333U}; + UInt64List = UInt64List ?? new ulong[]{11111111111111111111UL}; + Float32List = Float32List ?? new float[]{5555.5F, float.PositiveInfinity, float.NegativeInfinity, float.NaN}; + Float64List = Float64List ?? new double[]{7777.75, double.PositiveInfinity, double.NegativeInfinity, double.NaN}; + TextList = TextList ?? new string[]{"plugh", "xyzzy", "thud"}; + DataList = DataList ?? new IReadOnlyList[]{new byte[]{111, 111, 112, 115}, new byte[]{101, 120, 104, 97, 117, 115, 116, 101, 100}, new byte[]{114, 102, 99, 51, 48, 57, 50}}; + StructList = StructList ?? new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "structlist 1", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "structlist 2", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = "structlist 3", DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}; + EnumList = EnumList ?? new Capnproto_test.Capnp.Test.TestEnum[]{Capnproto_test.Capnp.Test.TestEnum.foo, Capnproto_test.Capnp.Test.TestEnum.garply}; + } + + public bool BoolField + { + get; + set; + } + + = true; + public sbyte Int8Field + { + get; + set; + } + + = -123; + public short Int16Field + { + get; + set; + } + + = -12345; + public int Int32Field + { + get; + set; + } + + = -12345678; + public long Int64Field + { + get; + set; + } + + = -123456789012345L; + public byte UInt8Field + { + get; + set; + } + + = 234; + public ushort UInt16Field + { + get; + set; + } + + = 45678; + public uint UInt32Field + { + get; + set; + } + + = 3456789012U; + public ulong UInt64Field + { + get; + set; + } + + = 12345678901234567890UL; + public float Float32Field + { + get; + set; + } + + = 1234.5F; + public double Float64Field + { + get; + set; + } + + = -1.23E+47; + public string TextField + { + get; + set; + } + + public IReadOnlyList DataField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestAllTypes StructField + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestEnum.corge; + public int VoidList + { + get; + set; + } + + = 6; + public IReadOnlyList BoolList + { + get; + set; + } + + public IReadOnlyList Int8List + { + get; + set; + } + + public IReadOnlyList Int16List + { + get; + set; + } + + public IReadOnlyList Int32List + { + get; + set; + } + + public IReadOnlyList Int64List + { + get; + set; + } + + public IReadOnlyList UInt8List + { + get; + set; + } + + public IReadOnlyList UInt16List + { + get; + set; + } + + public IReadOnlyList UInt32List + { + get; + set; + } + + public IReadOnlyList UInt64List + { + get; + set; + } + + public IReadOnlyList Float32List + { + get; + set; + } + + public IReadOnlyList Float64List + { + get; + set; + } + + public IReadOnlyList TextList + { + get; + set; + } + + public IReadOnlyList> DataList + { + get; + set; + } + + public IReadOnlyList StructList + { + get; + set; + } + + public IReadOnlyList EnumList + { + get; + set; + } + + public int InterfaceList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool BoolField => ctx.ReadDataBool(0UL, true); + public sbyte Int8Field => ctx.ReadDataSByte(8UL, (sbyte)-123); + public short Int16Field => ctx.ReadDataShort(16UL, (short)-12345); + public int Int32Field => ctx.ReadDataInt(32UL, -12345678); + public long Int64Field => ctx.ReadDataLong(64UL, -123456789012345L); + public byte UInt8Field => ctx.ReadDataByte(128UL, (byte)234); + public ushort UInt16Field => ctx.ReadDataUShort(144UL, (ushort)45678); + public uint UInt32Field => ctx.ReadDataUInt(160UL, 3456789012U); + public ulong UInt64Field => ctx.ReadDataULong(192UL, 12345678901234567890UL); + public float Float32Field => ctx.ReadDataFloat(256UL, 1234.5F); + public double Float64Field => ctx.ReadDataDouble(320UL, -1.23E+47); + public string TextField => ctx.ReadText(0, "foo"); + public IReadOnlyList DataField => ctx.ReadList(1).CastByte(); + public Capnproto_test.Capnp.Test.TestAllTypes.READER StructField => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public Capnproto_test.Capnp.Test.TestEnum EnumField => (Capnproto_test.Capnp.Test.TestEnum)ctx.ReadDataUShort(288UL, (ushort)5); + public int VoidList => ctx.ReadList(3).Count; + public IReadOnlyList BoolList => ctx.ReadList(4).CastBool(); + public IReadOnlyList Int8List => ctx.ReadList(5).CastSByte(); + public IReadOnlyList Int16List => ctx.ReadList(6).CastShort(); + public IReadOnlyList Int32List => ctx.ReadList(7).CastInt(); + public IReadOnlyList Int64List => ctx.ReadList(8).CastLong(); + public IReadOnlyList UInt8List => ctx.ReadList(9).CastByte(); + public IReadOnlyList UInt16List => ctx.ReadList(10).CastUShort(); + public IReadOnlyList UInt32List => ctx.ReadList(11).CastUInt(); + public IReadOnlyList UInt64List => ctx.ReadList(12).CastULong(); + public IReadOnlyList Float32List => ctx.ReadList(13).CastFloat(); + public IReadOnlyList Float64List => ctx.ReadList(14).CastDouble(); + public IReadOnlyList TextList => ctx.ReadList(15).CastText2(); + public IReadOnlyList> DataList => ctx.ReadList(16).CastData(); + public IReadOnlyList StructList => ctx.ReadList(17).Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public IReadOnlyList EnumList => ctx.ReadList(18).CastEnums(_0 => (Capnproto_test.Capnp.Test.TestEnum)_0); + public int InterfaceList => ctx.ReadList(19).Count; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(6, 20); + } + + public bool BoolField + { + get => this.ReadDataBool(0UL, true); + set => this.WriteData(0UL, value, true); + } + + public sbyte Int8Field + { + get => this.ReadDataSByte(8UL, (sbyte)-123); + set => this.WriteData(8UL, value, (sbyte)-123); + } + + public short Int16Field + { + get => this.ReadDataShort(16UL, (short)-12345); + set => this.WriteData(16UL, value, (short)-12345); + } + + public int Int32Field + { + get => this.ReadDataInt(32UL, -12345678); + set => this.WriteData(32UL, value, -12345678); + } + + public long Int64Field + { + get => this.ReadDataLong(64UL, -123456789012345L); + set => this.WriteData(64UL, value, -123456789012345L); + } + + public byte UInt8Field + { + get => this.ReadDataByte(128UL, (byte)234); + set => this.WriteData(128UL, value, (byte)234); + } + + public ushort UInt16Field + { + get => this.ReadDataUShort(144UL, (ushort)45678); + set => this.WriteData(144UL, value, (ushort)45678); + } + + public uint UInt32Field + { + get => this.ReadDataUInt(160UL, 3456789012U); + set => this.WriteData(160UL, value, 3456789012U); + } + + public ulong UInt64Field + { + get => this.ReadDataULong(192UL, 12345678901234567890UL); + set => this.WriteData(192UL, value, 12345678901234567890UL); + } + + public float Float32Field + { + get => this.ReadDataFloat(256UL, 1234.5F); + set => this.WriteData(256UL, value, 1234.5F); + } + + public double Float64Field + { + get => this.ReadDataDouble(320UL, -1.23E+47); + set => this.WriteData(320UL, value, -1.23E+47); + } + + public string TextField + { + get => this.ReadText(0, "foo"); + set => this.WriteText(0, value, "foo"); + } + + public ListOfPrimitivesSerializer DataField + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER StructField + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestEnum EnumField + { + get => (Capnproto_test.Capnp.Test.TestEnum)this.ReadDataUShort(288UL, (ushort)5); + set => this.WriteData(288UL, (ushort)value, (ushort)5); + } + + public ListOfEmptySerializer VoidList + { + get => BuildPointer(3); + set => Link(3, value); + } + + public ListOfBitsSerializer BoolList + { + get => BuildPointer(4); + set => Link(4, value); + } + + public ListOfPrimitivesSerializer Int8List + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public ListOfPrimitivesSerializer Int16List + { + get => BuildPointer>(6); + set => Link(6, value); + } + + public ListOfPrimitivesSerializer Int32List + { + get => BuildPointer>(7); + set => Link(7, value); + } + + public ListOfPrimitivesSerializer Int64List + { + get => BuildPointer>(8); + set => Link(8, value); + } + + public ListOfPrimitivesSerializer UInt8List + { + get => BuildPointer>(9); + set => Link(9, value); + } + + public ListOfPrimitivesSerializer UInt16List + { + get => BuildPointer>(10); + set => Link(10, value); + } + + public ListOfPrimitivesSerializer UInt32List + { + get => BuildPointer>(11); + set => Link(11, value); + } + + public ListOfPrimitivesSerializer UInt64List + { + get => BuildPointer>(12); + set => Link(12, value); + } + + public ListOfPrimitivesSerializer Float32List + { + get => BuildPointer>(13); + set => Link(13, value); + } + + public ListOfPrimitivesSerializer Float64List + { + get => BuildPointer>(14); + set => Link(14, value); + } + + public ListOfTextSerializer TextList + { + get => BuildPointer(15); + set => Link(15, value); + } + + public ListOfPointersSerializer> DataList + { + get => BuildPointer>>(16); + set => Link(16, value); + } + + public ListOfStructsSerializer StructList + { + get => BuildPointer>(17); + set => Link(17, value); + } + + public ListOfPrimitivesSerializer EnumList + { + get => BuildPointer>(18); + set => Link(18, value); + } + + public ListOfEmptySerializer InterfaceList + { + get => BuildPointer(19); + set => Link(19, value); + } + } + } + + public class TestAnyPointer : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + AnyPointerField = CapnpSerializable.Create(reader.AnyPointerField); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.AnyPointerField.SetObject(AnyPointerField); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer AnyPointerField + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState AnyPointerField => ctx.StructReadPointer(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public DynamicSerializerState AnyPointerField + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class TestAnyOthers : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + AnyStructField = CapnpSerializable.Create(reader.AnyStructField); + AnyListField = reader.AnyListField.ToReadOnlyList(_ => (object)_); + CapabilityField = reader.CapabilityField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.AnyStructField.SetObject(AnyStructField); + writer.AnyListField.SetObject(AnyListField); + writer.CapabilityField = CapabilityField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer AnyStructField + { + get; + set; + } + + public IReadOnlyList AnyListField + { + get; + set; + } + + public BareProxy CapabilityField + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState AnyStructField => ctx.StructReadPointer(0); + public IReadOnlyList AnyListField => (IReadOnlyList)ctx.ReadList(1); + public BareProxy CapabilityField => ctx.ReadCap(2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 3); + } + + public DynamicSerializerState AnyStructField + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState AnyListField + { + get => BuildPointer(1); + set => Link(1, value); + } + + public BareProxy CapabilityField + { + get => ReadCap(2); + set => LinkObject(2, value); + } + } + } + + public class TestOutOfOrder : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Qux = reader.Qux; + Grault = reader.Grault; + Bar = reader.Bar; + Foo = reader.Foo; + Corge = reader.Corge; + Waldo = reader.Waldo; + Quux = reader.Quux; + Garply = reader.Garply; + Baz = reader.Baz; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Qux = Qux; + writer.Grault = Grault; + writer.Bar = Bar; + writer.Foo = Foo; + writer.Corge = Corge; + writer.Waldo = Waldo; + writer.Quux = Quux; + writer.Garply = Garply; + writer.Baz = Baz; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Qux + { + get; + set; + } + + public string Grault + { + get; + set; + } + + public string Bar + { + get; + set; + } + + public string Foo + { + get; + set; + } + + public string Corge + { + get; + set; + } + + public string Waldo + { + get; + set; + } + + public string Quux + { + get; + set; + } + + public string Garply + { + get; + set; + } + + public string Baz + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Qux => ctx.ReadText(0, ""); + public string Grault => ctx.ReadText(1, ""); + public string Bar => ctx.ReadText(2, ""); + public string Foo => ctx.ReadText(3, ""); + public string Corge => ctx.ReadText(4, ""); + public string Waldo => ctx.ReadText(5, ""); + public string Quux => ctx.ReadText(6, ""); + public string Garply => ctx.ReadText(7, ""); + public string Baz => ctx.ReadText(8, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 9); + } + + public string Qux + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string Grault + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + + public string Bar + { + get => this.ReadText(2, ""); + set => this.WriteText(2, value, ""); + } + + public string Foo + { + get => this.ReadText(3, ""); + set => this.WriteText(3, value, ""); + } + + public string Corge + { + get => this.ReadText(4, ""); + set => this.WriteText(4, value, ""); + } + + public string Waldo + { + get => this.ReadText(5, ""); + set => this.WriteText(5, value, ""); + } + + public string Quux + { + get => this.ReadText(6, ""); + set => this.WriteText(6, value, ""); + } + + public string Garply + { + get => this.ReadText(7, ""); + set => this.WriteText(7, value, ""); + } + + public string Baz + { + get => this.ReadText(8, ""); + set => this.WriteText(8, value, ""); + } + } + } + + public class TestUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Union0 = CapnpSerializable.Create(reader.Union0); + Union1 = CapnpSerializable.Create(reader.Union1); + Union2 = CapnpSerializable.Create(reader.Union2); + Union3 = CapnpSerializable.Create(reader.Union3); + Bit0 = reader.Bit0; + Bit2 = reader.Bit2; + Bit3 = reader.Bit3; + Bit4 = reader.Bit4; + Bit5 = reader.Bit5; + Bit6 = reader.Bit6; + Bit7 = reader.Bit7; + Byte0 = reader.Byte0; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Union0?.serialize(writer.Union0); + Union1?.serialize(writer.Union1); + Union2?.serialize(writer.Union2); + Union3?.serialize(writer.Union3); + writer.Bit0 = Bit0; + writer.Bit2 = Bit2; + writer.Bit3 = Bit3; + writer.Bit4 = Bit4; + writer.Bit5 = Bit5; + writer.Bit6 = Bit6; + writer.Bit7 = Bit7; + writer.Byte0 = Byte0; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestUnion.@union0 Union0 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion.@union1 Union1 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion.@union2 Union2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion.@union3 Union3 + { + get; + set; + } + + public bool Bit0 + { + get; + set; + } + + public bool Bit2 + { + get; + set; + } + + public bool Bit3 + { + get; + set; + } + + public bool Bit4 + { + get; + set; + } + + public bool Bit5 + { + get; + set; + } + + public bool Bit6 + { + get; + set; + } + + public bool Bit7 + { + get; + set; + } + + public byte Byte0 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @union0.READER Union0 => new @union0.READER(ctx); + public @union1.READER Union1 => new @union1.READER(ctx); + public @union2.READER Union2 => new @union2.READER(ctx); + public @union3.READER Union3 => new @union3.READER(ctx); + public bool Bit0 => ctx.ReadDataBool(128UL, false); + public bool Bit2 => ctx.ReadDataBool(130UL, false); + public bool Bit3 => ctx.ReadDataBool(131UL, false); + public bool Bit4 => ctx.ReadDataBool(132UL, false); + public bool Bit5 => ctx.ReadDataBool(133UL, false); + public bool Bit6 => ctx.ReadDataBool(134UL, false); + public bool Bit7 => ctx.ReadDataBool(135UL, false); + public byte Byte0 => ctx.ReadDataByte(280UL, (byte)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(8, 2); + } + + public @union0.WRITER Union0 + { + get => Rewrap<@union0.WRITER>(); + } + + public @union1.WRITER Union1 + { + get => Rewrap<@union1.WRITER>(); + } + + public @union2.WRITER Union2 + { + get => Rewrap<@union2.WRITER>(); + } + + public @union3.WRITER Union3 + { + get => Rewrap<@union3.WRITER>(); + } + + public bool Bit0 + { + get => this.ReadDataBool(128UL, false); + set => this.WriteData(128UL, value, false); + } + + public bool Bit2 + { + get => this.ReadDataBool(130UL, false); + set => this.WriteData(130UL, value, false); + } + + public bool Bit3 + { + get => this.ReadDataBool(131UL, false); + set => this.WriteData(131UL, value, false); + } + + public bool Bit4 + { + get => this.ReadDataBool(132UL, false); + set => this.WriteData(132UL, value, false); + } + + public bool Bit5 + { + get => this.ReadDataBool(133UL, false); + set => this.WriteData(133UL, value, false); + } + + public bool Bit6 + { + get => this.ReadDataBool(134UL, false); + set => this.WriteData(134UL, value, false); + } + + public bool Bit7 + { + get => this.ReadDataBool(135UL, false); + set => this.WriteData(135UL, value, false); + } + + public byte Byte0 + { + get => this.ReadDataByte(280UL, (byte)0); + set => this.WriteData(280UL, value, (byte)0); + } + } + + public class @union0 : ICapnpSerializable + { + public enum WHICH : ushort + { + U0f0s0 = 0, + U0f0s1 = 1, + U0f0s8 = 2, + U0f0s16 = 3, + U0f0s32 = 4, + U0f0s64 = 5, + U0f0sp = 6, + U0f1s0 = 7, + U0f1s1 = 8, + U0f1s8 = 9, + U0f1s16 = 10, + U0f1s32 = 11, + U0f1s64 = 12, + U0f1sp = 13, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U0f0s0: + which = reader.which; + break; + case WHICH.U0f0s1: + U0f0s1 = reader.U0f0s1; + break; + case WHICH.U0f0s8: + U0f0s8 = reader.U0f0s8; + break; + case WHICH.U0f0s16: + U0f0s16 = reader.U0f0s16; + break; + case WHICH.U0f0s32: + U0f0s32 = reader.U0f0s32; + break; + case WHICH.U0f0s64: + U0f0s64 = reader.U0f0s64; + break; + case WHICH.U0f0sp: + U0f0sp = reader.U0f0sp; + break; + case WHICH.U0f1s0: + which = reader.which; + break; + case WHICH.U0f1s1: + U0f1s1 = reader.U0f1s1; + break; + case WHICH.U0f1s8: + U0f1s8 = reader.U0f1s8; + break; + case WHICH.U0f1s16: + U0f1s16 = reader.U0f1s16; + break; + case WHICH.U0f1s32: + U0f1s32 = reader.U0f1s32; + break; + case WHICH.U0f1s64: + U0f1s64 = reader.U0f1s64; + break; + case WHICH.U0f1sp: + U0f1sp = reader.U0f1sp; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U0f0s0: + break; + case WHICH.U0f0s1: + _content = false; + break; + case WHICH.U0f0s8: + _content = 0; + break; + case WHICH.U0f0s16: + _content = 0; + break; + case WHICH.U0f0s32: + _content = 0; + break; + case WHICH.U0f0s64: + _content = 0; + break; + case WHICH.U0f0sp: + _content = null; + break; + case WHICH.U0f1s0: + break; + case WHICH.U0f1s1: + _content = false; + break; + case WHICH.U0f1s8: + _content = 0; + break; + case WHICH.U0f1s16: + _content = 0; + break; + case WHICH.U0f1s32: + _content = 0; + break; + case WHICH.U0f1s64: + _content = 0; + break; + case WHICH.U0f1sp: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U0f0s0: + break; + case WHICH.U0f0s1: + writer.U0f0s1 = U0f0s1.Value; + break; + case WHICH.U0f0s8: + writer.U0f0s8 = U0f0s8.Value; + break; + case WHICH.U0f0s16: + writer.U0f0s16 = U0f0s16.Value; + break; + case WHICH.U0f0s32: + writer.U0f0s32 = U0f0s32.Value; + break; + case WHICH.U0f0s64: + writer.U0f0s64 = U0f0s64.Value; + break; + case WHICH.U0f0sp: + writer.U0f0sp = U0f0sp; + break; + case WHICH.U0f1s0: + break; + case WHICH.U0f1s1: + writer.U0f1s1 = U0f1s1.Value; + break; + case WHICH.U0f1s8: + writer.U0f1s8 = U0f1s8.Value; + break; + case WHICH.U0f1s16: + writer.U0f1s16 = U0f1s16.Value; + break; + case WHICH.U0f1s32: + writer.U0f1s32 = U0f1s32.Value; + break; + case WHICH.U0f1s64: + writer.U0f1s64 = U0f1s64.Value; + break; + case WHICH.U0f1sp: + writer.U0f1sp = U0f1sp; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U0f0s1 + { + get => _which == WHICH.U0f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U0f0s1; + _content = value; + } + } + + public sbyte? U0f0s8 + { + get => _which == WHICH.U0f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U0f0s8; + _content = value; + } + } + + public short? U0f0s16 + { + get => _which == WHICH.U0f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U0f0s16; + _content = value; + } + } + + public int? U0f0s32 + { + get => _which == WHICH.U0f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U0f0s32; + _content = value; + } + } + + public long? U0f0s64 + { + get => _which == WHICH.U0f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U0f0s64; + _content = value; + } + } + + public string U0f0sp + { + get => _which == WHICH.U0f0sp ? (string)_content : null; + set + { + _which = WHICH.U0f0sp; + _content = value; + } + } + + public bool? U0f1s1 + { + get => _which == WHICH.U0f1s1 ? (bool? )_content : null; + set + { + _which = WHICH.U0f1s1; + _content = value; + } + } + + public sbyte? U0f1s8 + { + get => _which == WHICH.U0f1s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U0f1s8; + _content = value; + } + } + + public short? U0f1s16 + { + get => _which == WHICH.U0f1s16 ? (short? )_content : null; + set + { + _which = WHICH.U0f1s16; + _content = value; + } + } + + public int? U0f1s32 + { + get => _which == WHICH.U0f1s32 ? (int? )_content : null; + set + { + _which = WHICH.U0f1s32; + _content = value; + } + } + + public long? U0f1s64 + { + get => _which == WHICH.U0f1s64 ? (long? )_content : null; + set + { + _which = WHICH.U0f1s64; + _content = value; + } + } + + public string U0f1sp + { + get => _which == WHICH.U0f1sp ? (string)_content : null; + set + { + _which = WHICH.U0f1sp; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public bool U0f0s1 => which == WHICH.U0f0s1 ? ctx.ReadDataBool(64UL, false) : default; + public sbyte U0f0s8 => which == WHICH.U0f0s8 ? ctx.ReadDataSByte(64UL, (sbyte)0) : default; + public short U0f0s16 => which == WHICH.U0f0s16 ? ctx.ReadDataShort(64UL, (short)0) : default; + public int U0f0s32 => which == WHICH.U0f0s32 ? ctx.ReadDataInt(64UL, 0) : default; + public long U0f0s64 => which == WHICH.U0f0s64 ? ctx.ReadDataLong(64UL, 0L) : default; + public string U0f0sp => which == WHICH.U0f0sp ? ctx.ReadText(0, "") : default; + public bool U0f1s1 => which == WHICH.U0f1s1 ? ctx.ReadDataBool(64UL, false) : default; + public sbyte U0f1s8 => which == WHICH.U0f1s8 ? ctx.ReadDataSByte(64UL, (sbyte)0) : default; + public short U0f1s16 => which == WHICH.U0f1s16 ? ctx.ReadDataShort(64UL, (short)0) : default; + public int U0f1s32 => which == WHICH.U0f1s32 ? ctx.ReadDataInt(64UL, 0) : default; + public long U0f1s64 => which == WHICH.U0f1s64 ? ctx.ReadDataLong(64UL, 0L) : default; + public string U0f1sp => which == WHICH.U0f1sp ? ctx.ReadText(0, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public bool U0f0s1 + { + get => which == WHICH.U0f0s1 ? this.ReadDataBool(64UL, false) : default; + set => this.WriteData(64UL, value, false); + } + + public sbyte U0f0s8 + { + get => which == WHICH.U0f0s8 ? this.ReadDataSByte(64UL, (sbyte)0) : default; + set => this.WriteData(64UL, value, (sbyte)0); + } + + public short U0f0s16 + { + get => which == WHICH.U0f0s16 ? this.ReadDataShort(64UL, (short)0) : default; + set => this.WriteData(64UL, value, (short)0); + } + + public int U0f0s32 + { + get => which == WHICH.U0f0s32 ? this.ReadDataInt(64UL, 0) : default; + set => this.WriteData(64UL, value, 0); + } + + public long U0f0s64 + { + get => which == WHICH.U0f0s64 ? this.ReadDataLong(64UL, 0L) : default; + set => this.WriteData(64UL, value, 0L); + } + + public string U0f0sp + { + get => which == WHICH.U0f0sp ? this.ReadText(0, "") : default; + set => this.WriteText(0, value, ""); + } + + public bool U0f1s1 + { + get => which == WHICH.U0f1s1 ? this.ReadDataBool(64UL, false) : default; + set => this.WriteData(64UL, value, false); + } + + public sbyte U0f1s8 + { + get => which == WHICH.U0f1s8 ? this.ReadDataSByte(64UL, (sbyte)0) : default; + set => this.WriteData(64UL, value, (sbyte)0); + } + + public short U0f1s16 + { + get => which == WHICH.U0f1s16 ? this.ReadDataShort(64UL, (short)0) : default; + set => this.WriteData(64UL, value, (short)0); + } + + public int U0f1s32 + { + get => which == WHICH.U0f1s32 ? this.ReadDataInt(64UL, 0) : default; + set => this.WriteData(64UL, value, 0); + } + + public long U0f1s64 + { + get => which == WHICH.U0f1s64 ? this.ReadDataLong(64UL, 0L) : default; + set => this.WriteData(64UL, value, 0L); + } + + public string U0f1sp + { + get => which == WHICH.U0f1sp ? this.ReadText(0, "") : default; + set => this.WriteText(0, value, ""); + } + } + } + + public class @union1 : ICapnpSerializable + { + public enum WHICH : ushort + { + U1f0s0 = 0, + U1f0s1 = 1, + U1f1s1 = 2, + U1f0s8 = 3, + U1f1s8 = 4, + U1f0s16 = 5, + U1f1s16 = 6, + U1f0s32 = 7, + U1f1s32 = 8, + U1f0s64 = 9, + U1f1s64 = 10, + U1f0sp = 11, + U1f1sp = 12, + U1f2s0 = 13, + U1f2s1 = 14, + U1f2s8 = 15, + U1f2s16 = 16, + U1f2s32 = 17, + U1f2s64 = 18, + U1f2sp = 19, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U1f0s0: + which = reader.which; + break; + case WHICH.U1f0s1: + U1f0s1 = reader.U1f0s1; + break; + case WHICH.U1f1s1: + U1f1s1 = reader.U1f1s1; + break; + case WHICH.U1f0s8: + U1f0s8 = reader.U1f0s8; + break; + case WHICH.U1f1s8: + U1f1s8 = reader.U1f1s8; + break; + case WHICH.U1f0s16: + U1f0s16 = reader.U1f0s16; + break; + case WHICH.U1f1s16: + U1f1s16 = reader.U1f1s16; + break; + case WHICH.U1f0s32: + U1f0s32 = reader.U1f0s32; + break; + case WHICH.U1f1s32: + U1f1s32 = reader.U1f1s32; + break; + case WHICH.U1f0s64: + U1f0s64 = reader.U1f0s64; + break; + case WHICH.U1f1s64: + U1f1s64 = reader.U1f1s64; + break; + case WHICH.U1f0sp: + U1f0sp = reader.U1f0sp; + break; + case WHICH.U1f1sp: + U1f1sp = reader.U1f1sp; + break; + case WHICH.U1f2s0: + which = reader.which; + break; + case WHICH.U1f2s1: + U1f2s1 = reader.U1f2s1; + break; + case WHICH.U1f2s8: + U1f2s8 = reader.U1f2s8; + break; + case WHICH.U1f2s16: + U1f2s16 = reader.U1f2s16; + break; + case WHICH.U1f2s32: + U1f2s32 = reader.U1f2s32; + break; + case WHICH.U1f2s64: + U1f2s64 = reader.U1f2s64; + break; + case WHICH.U1f2sp: + U1f2sp = reader.U1f2sp; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U1f0s0: + break; + case WHICH.U1f0s1: + _content = false; + break; + case WHICH.U1f1s1: + _content = false; + break; + case WHICH.U1f0s8: + _content = 0; + break; + case WHICH.U1f1s8: + _content = 0; + break; + case WHICH.U1f0s16: + _content = 0; + break; + case WHICH.U1f1s16: + _content = 0; + break; + case WHICH.U1f0s32: + _content = 0; + break; + case WHICH.U1f1s32: + _content = 0; + break; + case WHICH.U1f0s64: + _content = 0; + break; + case WHICH.U1f1s64: + _content = 0; + break; + case WHICH.U1f0sp: + _content = null; + break; + case WHICH.U1f1sp: + _content = null; + break; + case WHICH.U1f2s0: + break; + case WHICH.U1f2s1: + _content = false; + break; + case WHICH.U1f2s8: + _content = 0; + break; + case WHICH.U1f2s16: + _content = 0; + break; + case WHICH.U1f2s32: + _content = 0; + break; + case WHICH.U1f2s64: + _content = 0; + break; + case WHICH.U1f2sp: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U1f0s0: + break; + case WHICH.U1f0s1: + writer.U1f0s1 = U1f0s1.Value; + break; + case WHICH.U1f1s1: + writer.U1f1s1 = U1f1s1.Value; + break; + case WHICH.U1f0s8: + writer.U1f0s8 = U1f0s8.Value; + break; + case WHICH.U1f1s8: + writer.U1f1s8 = U1f1s8.Value; + break; + case WHICH.U1f0s16: + writer.U1f0s16 = U1f0s16.Value; + break; + case WHICH.U1f1s16: + writer.U1f1s16 = U1f1s16.Value; + break; + case WHICH.U1f0s32: + writer.U1f0s32 = U1f0s32.Value; + break; + case WHICH.U1f1s32: + writer.U1f1s32 = U1f1s32.Value; + break; + case WHICH.U1f0s64: + writer.U1f0s64 = U1f0s64.Value; + break; + case WHICH.U1f1s64: + writer.U1f1s64 = U1f1s64.Value; + break; + case WHICH.U1f0sp: + writer.U1f0sp = U1f0sp; + break; + case WHICH.U1f1sp: + writer.U1f1sp = U1f1sp; + break; + case WHICH.U1f2s0: + break; + case WHICH.U1f2s1: + writer.U1f2s1 = U1f2s1.Value; + break; + case WHICH.U1f2s8: + writer.U1f2s8 = U1f2s8.Value; + break; + case WHICH.U1f2s16: + writer.U1f2s16 = U1f2s16.Value; + break; + case WHICH.U1f2s32: + writer.U1f2s32 = U1f2s32.Value; + break; + case WHICH.U1f2s64: + writer.U1f2s64 = U1f2s64.Value; + break; + case WHICH.U1f2sp: + writer.U1f2sp = U1f2sp; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U1f0s1 + { + get => _which == WHICH.U1f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U1f0s1; + _content = value; + } + } + + public bool? U1f1s1 + { + get => _which == WHICH.U1f1s1 ? (bool? )_content : null; + set + { + _which = WHICH.U1f1s1; + _content = value; + } + } + + public sbyte? U1f0s8 + { + get => _which == WHICH.U1f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U1f0s8; + _content = value; + } + } + + public sbyte? U1f1s8 + { + get => _which == WHICH.U1f1s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U1f1s8; + _content = value; + } + } + + public short? U1f0s16 + { + get => _which == WHICH.U1f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U1f0s16; + _content = value; + } + } + + public short? U1f1s16 + { + get => _which == WHICH.U1f1s16 ? (short? )_content : null; + set + { + _which = WHICH.U1f1s16; + _content = value; + } + } + + public int? U1f0s32 + { + get => _which == WHICH.U1f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U1f0s32; + _content = value; + } + } + + public int? U1f1s32 + { + get => _which == WHICH.U1f1s32 ? (int? )_content : null; + set + { + _which = WHICH.U1f1s32; + _content = value; + } + } + + public long? U1f0s64 + { + get => _which == WHICH.U1f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U1f0s64; + _content = value; + } + } + + public long? U1f1s64 + { + get => _which == WHICH.U1f1s64 ? (long? )_content : null; + set + { + _which = WHICH.U1f1s64; + _content = value; + } + } + + public string U1f0sp + { + get => _which == WHICH.U1f0sp ? (string)_content : null; + set + { + _which = WHICH.U1f0sp; + _content = value; + } + } + + public string U1f1sp + { + get => _which == WHICH.U1f1sp ? (string)_content : null; + set + { + _which = WHICH.U1f1sp; + _content = value; + } + } + + public bool? U1f2s1 + { + get => _which == WHICH.U1f2s1 ? (bool? )_content : null; + set + { + _which = WHICH.U1f2s1; + _content = value; + } + } + + public sbyte? U1f2s8 + { + get => _which == WHICH.U1f2s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U1f2s8; + _content = value; + } + } + + public short? U1f2s16 + { + get => _which == WHICH.U1f2s16 ? (short? )_content : null; + set + { + _which = WHICH.U1f2s16; + _content = value; + } + } + + public int? U1f2s32 + { + get => _which == WHICH.U1f2s32 ? (int? )_content : null; + set + { + _which = WHICH.U1f2s32; + _content = value; + } + } + + public long? U1f2s64 + { + get => _which == WHICH.U1f2s64 ? (long? )_content : null; + set + { + _which = WHICH.U1f2s64; + _content = value; + } + } + + public string U1f2sp + { + get => _which == WHICH.U1f2sp ? (string)_content : null; + set + { + _which = WHICH.U1f2sp; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(16U, (ushort)0); + public bool U1f0s1 => which == WHICH.U1f0s1 ? ctx.ReadDataBool(129UL, false) : default; + public bool U1f1s1 => which == WHICH.U1f1s1 ? ctx.ReadDataBool(129UL, false) : default; + public sbyte U1f0s8 => which == WHICH.U1f0s8 ? ctx.ReadDataSByte(136UL, (sbyte)0) : default; + public sbyte U1f1s8 => which == WHICH.U1f1s8 ? ctx.ReadDataSByte(136UL, (sbyte)0) : default; + public short U1f0s16 => which == WHICH.U1f0s16 ? ctx.ReadDataShort(144UL, (short)0) : default; + public short U1f1s16 => which == WHICH.U1f1s16 ? ctx.ReadDataShort(144UL, (short)0) : default; + public int U1f0s32 => which == WHICH.U1f0s32 ? ctx.ReadDataInt(160UL, 0) : default; + public int U1f1s32 => which == WHICH.U1f1s32 ? ctx.ReadDataInt(160UL, 0) : default; + public long U1f0s64 => which == WHICH.U1f0s64 ? ctx.ReadDataLong(192UL, 0L) : default; + public long U1f1s64 => which == WHICH.U1f1s64 ? ctx.ReadDataLong(192UL, 0L) : default; + public string U1f0sp => which == WHICH.U1f0sp ? ctx.ReadText(1, "") : default; + public string U1f1sp => which == WHICH.U1f1sp ? ctx.ReadText(1, "") : default; + public bool U1f2s1 => which == WHICH.U1f2s1 ? ctx.ReadDataBool(129UL, false) : default; + public sbyte U1f2s8 => which == WHICH.U1f2s8 ? ctx.ReadDataSByte(136UL, (sbyte)0) : default; + public short U1f2s16 => which == WHICH.U1f2s16 ? ctx.ReadDataShort(144UL, (short)0) : default; + public int U1f2s32 => which == WHICH.U1f2s32 ? ctx.ReadDataInt(160UL, 0) : default; + public long U1f2s64 => which == WHICH.U1f2s64 ? ctx.ReadDataLong(192UL, 0L) : default; + public string U1f2sp => which == WHICH.U1f2sp ? ctx.ReadText(1, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(16U, (ushort)0); + set => this.WriteData(16U, (ushort)value, (ushort)0); + } + + public bool U1f0s1 + { + get => which == WHICH.U1f0s1 ? this.ReadDataBool(129UL, false) : default; + set => this.WriteData(129UL, value, false); + } + + public bool U1f1s1 + { + get => which == WHICH.U1f1s1 ? this.ReadDataBool(129UL, false) : default; + set => this.WriteData(129UL, value, false); + } + + public sbyte U1f0s8 + { + get => which == WHICH.U1f0s8 ? this.ReadDataSByte(136UL, (sbyte)0) : default; + set => this.WriteData(136UL, value, (sbyte)0); + } + + public sbyte U1f1s8 + { + get => which == WHICH.U1f1s8 ? this.ReadDataSByte(136UL, (sbyte)0) : default; + set => this.WriteData(136UL, value, (sbyte)0); + } + + public short U1f0s16 + { + get => which == WHICH.U1f0s16 ? this.ReadDataShort(144UL, (short)0) : default; + set => this.WriteData(144UL, value, (short)0); + } + + public short U1f1s16 + { + get => which == WHICH.U1f1s16 ? this.ReadDataShort(144UL, (short)0) : default; + set => this.WriteData(144UL, value, (short)0); + } + + public int U1f0s32 + { + get => which == WHICH.U1f0s32 ? this.ReadDataInt(160UL, 0) : default; + set => this.WriteData(160UL, value, 0); + } + + public int U1f1s32 + { + get => which == WHICH.U1f1s32 ? this.ReadDataInt(160UL, 0) : default; + set => this.WriteData(160UL, value, 0); + } + + public long U1f0s64 + { + get => which == WHICH.U1f0s64 ? this.ReadDataLong(192UL, 0L) : default; + set => this.WriteData(192UL, value, 0L); + } + + public long U1f1s64 + { + get => which == WHICH.U1f1s64 ? this.ReadDataLong(192UL, 0L) : default; + set => this.WriteData(192UL, value, 0L); + } + + public string U1f0sp + { + get => which == WHICH.U1f0sp ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + + public string U1f1sp + { + get => which == WHICH.U1f1sp ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + + public bool U1f2s1 + { + get => which == WHICH.U1f2s1 ? this.ReadDataBool(129UL, false) : default; + set => this.WriteData(129UL, value, false); + } + + public sbyte U1f2s8 + { + get => which == WHICH.U1f2s8 ? this.ReadDataSByte(136UL, (sbyte)0) : default; + set => this.WriteData(136UL, value, (sbyte)0); + } + + public short U1f2s16 + { + get => which == WHICH.U1f2s16 ? this.ReadDataShort(144UL, (short)0) : default; + set => this.WriteData(144UL, value, (short)0); + } + + public int U1f2s32 + { + get => which == WHICH.U1f2s32 ? this.ReadDataInt(160UL, 0) : default; + set => this.WriteData(160UL, value, 0); + } + + public long U1f2s64 + { + get => which == WHICH.U1f2s64 ? this.ReadDataLong(192UL, 0L) : default; + set => this.WriteData(192UL, value, 0L); + } + + public string U1f2sp + { + get => which == WHICH.U1f2sp ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + } + } + + public class @union2 : ICapnpSerializable + { + public enum WHICH : ushort + { + U2f0s1 = 0, + U2f0s8 = 1, + U2f0s16 = 2, + U2f0s32 = 3, + U2f0s64 = 4, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U2f0s1: + U2f0s1 = reader.U2f0s1; + break; + case WHICH.U2f0s8: + U2f0s8 = reader.U2f0s8; + break; + case WHICH.U2f0s16: + U2f0s16 = reader.U2f0s16; + break; + case WHICH.U2f0s32: + U2f0s32 = reader.U2f0s32; + break; + case WHICH.U2f0s64: + U2f0s64 = reader.U2f0s64; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U2f0s1: + _content = false; + break; + case WHICH.U2f0s8: + _content = 0; + break; + case WHICH.U2f0s16: + _content = 0; + break; + case WHICH.U2f0s32: + _content = 0; + break; + case WHICH.U2f0s64: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U2f0s1: + writer.U2f0s1 = U2f0s1.Value; + break; + case WHICH.U2f0s8: + writer.U2f0s8 = U2f0s8.Value; + break; + case WHICH.U2f0s16: + writer.U2f0s16 = U2f0s16.Value; + break; + case WHICH.U2f0s32: + writer.U2f0s32 = U2f0s32.Value; + break; + case WHICH.U2f0s64: + writer.U2f0s64 = U2f0s64.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U2f0s1 + { + get => _which == WHICH.U2f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U2f0s1; + _content = value; + } + } + + public sbyte? U2f0s8 + { + get => _which == WHICH.U2f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U2f0s8; + _content = value; + } + } + + public short? U2f0s16 + { + get => _which == WHICH.U2f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U2f0s16; + _content = value; + } + } + + public int? U2f0s32 + { + get => _which == WHICH.U2f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U2f0s32; + _content = value; + } + } + + public long? U2f0s64 + { + get => _which == WHICH.U2f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U2f0s64; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public bool U2f0s1 => which == WHICH.U2f0s1 ? ctx.ReadDataBool(256UL, false) : default; + public sbyte U2f0s8 => which == WHICH.U2f0s8 ? ctx.ReadDataSByte(264UL, (sbyte)0) : default; + public short U2f0s16 => which == WHICH.U2f0s16 ? ctx.ReadDataShort(288UL, (short)0) : default; + public int U2f0s32 => which == WHICH.U2f0s32 ? ctx.ReadDataInt(320UL, 0) : default; + public long U2f0s64 => which == WHICH.U2f0s64 ? ctx.ReadDataLong(384UL, 0L) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public bool U2f0s1 + { + get => which == WHICH.U2f0s1 ? this.ReadDataBool(256UL, false) : default; + set => this.WriteData(256UL, value, false); + } + + public sbyte U2f0s8 + { + get => which == WHICH.U2f0s8 ? this.ReadDataSByte(264UL, (sbyte)0) : default; + set => this.WriteData(264UL, value, (sbyte)0); + } + + public short U2f0s16 + { + get => which == WHICH.U2f0s16 ? this.ReadDataShort(288UL, (short)0) : default; + set => this.WriteData(288UL, value, (short)0); + } + + public int U2f0s32 + { + get => which == WHICH.U2f0s32 ? this.ReadDataInt(320UL, 0) : default; + set => this.WriteData(320UL, value, 0); + } + + public long U2f0s64 + { + get => which == WHICH.U2f0s64 ? this.ReadDataLong(384UL, 0L) : default; + set => this.WriteData(384UL, value, 0L); + } + } + } + + public class @union3 : ICapnpSerializable + { + public enum WHICH : ushort + { + U3f0s1 = 0, + U3f0s8 = 1, + U3f0s16 = 2, + U3f0s32 = 3, + U3f0s64 = 4, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.U3f0s1: + U3f0s1 = reader.U3f0s1; + break; + case WHICH.U3f0s8: + U3f0s8 = reader.U3f0s8; + break; + case WHICH.U3f0s16: + U3f0s16 = reader.U3f0s16; + break; + case WHICH.U3f0s32: + U3f0s32 = reader.U3f0s32; + break; + case WHICH.U3f0s64: + U3f0s64 = reader.U3f0s64; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.U3f0s1: + _content = false; + break; + case WHICH.U3f0s8: + _content = 0; + break; + case WHICH.U3f0s16: + _content = 0; + break; + case WHICH.U3f0s32: + _content = 0; + break; + case WHICH.U3f0s64: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.U3f0s1: + writer.U3f0s1 = U3f0s1.Value; + break; + case WHICH.U3f0s8: + writer.U3f0s8 = U3f0s8.Value; + break; + case WHICH.U3f0s16: + writer.U3f0s16 = U3f0s16.Value; + break; + case WHICH.U3f0s32: + writer.U3f0s32 = U3f0s32.Value; + break; + case WHICH.U3f0s64: + writer.U3f0s64 = U3f0s64.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? U3f0s1 + { + get => _which == WHICH.U3f0s1 ? (bool? )_content : null; + set + { + _which = WHICH.U3f0s1; + _content = value; + } + } + + public sbyte? U3f0s8 + { + get => _which == WHICH.U3f0s8 ? (sbyte? )_content : null; + set + { + _which = WHICH.U3f0s8; + _content = value; + } + } + + public short? U3f0s16 + { + get => _which == WHICH.U3f0s16 ? (short? )_content : null; + set + { + _which = WHICH.U3f0s16; + _content = value; + } + } + + public int? U3f0s32 + { + get => _which == WHICH.U3f0s32 ? (int? )_content : null; + set + { + _which = WHICH.U3f0s32; + _content = value; + } + } + + public long? U3f0s64 + { + get => _which == WHICH.U3f0s64 ? (long? )_content : null; + set + { + _which = WHICH.U3f0s64; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public bool U3f0s1 => which == WHICH.U3f0s1 ? ctx.ReadDataBool(257UL, false) : default; + public sbyte U3f0s8 => which == WHICH.U3f0s8 ? ctx.ReadDataSByte(272UL, (sbyte)0) : default; + public short U3f0s16 => which == WHICH.U3f0s16 ? ctx.ReadDataShort(304UL, (short)0) : default; + public int U3f0s32 => which == WHICH.U3f0s32 ? ctx.ReadDataInt(352UL, 0) : default; + public long U3f0s64 => which == WHICH.U3f0s64 ? ctx.ReadDataLong(448UL, 0L) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public bool U3f0s1 + { + get => which == WHICH.U3f0s1 ? this.ReadDataBool(257UL, false) : default; + set => this.WriteData(257UL, value, false); + } + + public sbyte U3f0s8 + { + get => which == WHICH.U3f0s8 ? this.ReadDataSByte(272UL, (sbyte)0) : default; + set => this.WriteData(272UL, value, (sbyte)0); + } + + public short U3f0s16 + { + get => which == WHICH.U3f0s16 ? this.ReadDataShort(304UL, (short)0) : default; + set => this.WriteData(304UL, value, (short)0); + } + + public int U3f0s32 + { + get => which == WHICH.U3f0s32 ? this.ReadDataInt(352UL, 0) : default; + set => this.WriteData(352UL, value, 0); + } + + public long U3f0s64 + { + get => which == WHICH.U3f0s64 ? this.ReadDataLong(448UL, 0L) : default; + set => this.WriteData(448UL, value, 0L); + } + } + } + } + + public class TestUnnamedUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = reader.Foo; + break; + case WHICH.Bar: + Bar = reader.Bar; + break; + } + + Before = reader.Before; + Middle = reader.Middle; + After = reader.After; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = 0; + break; + case WHICH.Bar: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo = Foo.Value; + break; + case WHICH.Bar: + writer.Bar = Bar.Value; + break; + } + + writer.Before = Before; + writer.Middle = Middle; + writer.After = After; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Before + { + get; + set; + } + + public ushort? Foo + { + get => _which == WHICH.Foo ? (ushort? )_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public ushort Middle + { + get; + set; + } + + public uint? Bar + { + get => _which == WHICH.Bar ? (uint? )_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public string After + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public string Before => ctx.ReadText(0, ""); + public ushort Foo => which == WHICH.Foo ? ctx.ReadDataUShort(0UL, (ushort)0) : default; + public ushort Middle => ctx.ReadDataUShort(16UL, (ushort)0); + public uint Bar => which == WHICH.Bar ? ctx.ReadDataUInt(64UL, 0U) : default; + public string After => ctx.ReadText(1, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 2); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public string Before + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ushort Foo + { + get => which == WHICH.Foo ? this.ReadDataUShort(0UL, (ushort)0) : default; + set => this.WriteData(0UL, value, (ushort)0); + } + + public ushort Middle + { + get => this.ReadDataUShort(16UL, (ushort)0); + set => this.WriteData(16UL, value, (ushort)0); + } + + public uint Bar + { + get => which == WHICH.Bar ? this.ReadDataUInt(64UL, 0U) : default; + set => this.WriteData(64UL, value, 0U); + } + + public string After + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + } + } + + public class TestUnionInUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Outer = CapnpSerializable.Create(reader.Outer); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Outer?.serialize(writer.Outer); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestUnionInUnion.@outer Outer + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @outer.READER Outer => new @outer.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 0); + } + + public @outer.WRITER Outer + { + get => Rewrap<@outer.WRITER>(); + } + } + + public class @outer : ICapnpSerializable + { + public enum WHICH : ushort + { + Inner = 0, + Baz = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Inner: + Inner = CapnpSerializable.Create(reader.Inner); + break; + case WHICH.Baz: + Baz = reader.Baz; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Inner: + _content = null; + break; + case WHICH.Baz: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Inner: + Inner?.serialize(writer.Inner); + break; + case WHICH.Baz: + writer.Baz = Baz.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestUnionInUnion.@outer.@inner Inner + { + get => _which == WHICH.Inner ? (Capnproto_test.Capnp.Test.TestUnionInUnion.@outer.@inner)_content : null; + set + { + _which = WHICH.Inner; + _content = value; + } + } + + public int? Baz + { + get => _which == WHICH.Baz ? (int? )_content : null; + set + { + _which = WHICH.Baz; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(64U, (ushort)0); + public @inner.READER Inner => which == WHICH.Inner ? new @inner.READER(ctx) : default; + public int Baz => which == WHICH.Baz ? ctx.ReadDataInt(0UL, 0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(64U, (ushort)0); + set => this.WriteData(64U, (ushort)value, (ushort)0); + } + + public @inner.WRITER Inner + { + get => which == WHICH.Inner ? Rewrap<@inner.WRITER>() : default; + } + + public int Baz + { + get => which == WHICH.Baz ? this.ReadDataInt(0UL, 0) : default; + set => this.WriteData(0UL, value, 0); + } + } + + public class @inner : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = reader.Foo; + break; + case WHICH.Bar: + Bar = reader.Bar; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = 0; + break; + case WHICH.Bar: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo = Foo.Value; + break; + case WHICH.Bar: + writer.Bar = Bar.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int? Foo + { + get => _which == WHICH.Foo ? (int? )_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public int? Bar + { + get => _which == WHICH.Bar ? (int? )_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public int Foo => which == WHICH.Foo ? ctx.ReadDataInt(0UL, 0) : default; + public int Bar => which == WHICH.Bar ? ctx.ReadDataInt(0UL, 0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public int Foo + { + get => which == WHICH.Foo ? this.ReadDataInt(0UL, 0) : default; + set => this.WriteData(0UL, value, 0); + } + + public int Bar + { + get => which == WHICH.Bar ? this.ReadDataInt(0UL, 0) : default; + set => this.WriteData(0UL, value, 0); + } + } + } + } + } + + public class TestGroups : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Groups = CapnpSerializable.Create(reader.Groups); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Groups?.serialize(writer.Groups); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups Groups + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @groups.READER Groups => new @groups.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 2); + } + + public @groups.WRITER Groups + { + get => Rewrap<@groups.WRITER>(); + } + } + + public class @groups : ICapnpSerializable + { + public enum WHICH : ushort + { + Foo = 0, + Baz = 1, + Bar = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = CapnpSerializable.Create(reader.Foo); + break; + case WHICH.Baz: + Baz = CapnpSerializable.Create(reader.Baz); + break; + case WHICH.Bar: + Bar = CapnpSerializable.Create(reader.Bar); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = null; + break; + case WHICH.Baz: + _content = null; + break; + case WHICH.Bar: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + Foo?.serialize(writer.Foo); + break; + case WHICH.Baz: + Baz?.serialize(writer.Baz); + break; + case WHICH.Bar: + Bar?.serialize(writer.Bar); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups.@foo Foo + { + get => _which == WHICH.Foo ? (Capnproto_test.Capnp.Test.TestGroups.@groups.@foo)_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups.@baz Baz + { + get => _which == WHICH.Baz ? (Capnproto_test.Capnp.Test.TestGroups.@groups.@baz)_content : null; + set + { + _which = WHICH.Baz; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestGroups.@groups.@bar Bar + { + get => _which == WHICH.Bar ? (Capnproto_test.Capnp.Test.TestGroups.@groups.@bar)_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(32U, (ushort)0); + public @foo.READER Foo => which == WHICH.Foo ? new @foo.READER(ctx) : default; + public @baz.READER Baz => which == WHICH.Baz ? new @baz.READER(ctx) : default; + public @bar.READER Bar => which == WHICH.Bar ? new @bar.READER(ctx) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(32U, (ushort)0); + set => this.WriteData(32U, (ushort)value, (ushort)0); + } + + public @foo.WRITER Foo + { + get => which == WHICH.Foo ? Rewrap<@foo.WRITER>() : default; + } + + public @baz.WRITER Baz + { + get => which == WHICH.Baz ? Rewrap<@baz.WRITER>() : default; + } + + public @bar.WRITER Bar + { + get => which == WHICH.Bar ? Rewrap<@bar.WRITER>() : default; + } + } + + public class @foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Corge = reader.Corge; + Grault = reader.Grault; + Garply = reader.Garply; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Corge = Corge; + writer.Grault = Grault; + writer.Garply = Garply; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Corge + { + get; + set; + } + + public long Grault + { + get; + set; + } + + public string Garply + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Corge => ctx.ReadDataInt(0UL, 0); + public long Grault => ctx.ReadDataLong(64UL, 0L); + public string Garply => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Corge + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public long Grault + { + get => this.ReadDataLong(64UL, 0L); + set => this.WriteData(64UL, value, 0L); + } + + public string Garply + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class @baz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Corge = reader.Corge; + Grault = reader.Grault; + Garply = reader.Garply; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Corge = Corge; + writer.Grault = Grault; + writer.Garply = Garply; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Corge + { + get; + set; + } + + public string Grault + { + get; + set; + } + + public string Garply + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Corge => ctx.ReadDataInt(0UL, 0); + public string Grault => ctx.ReadText(0, ""); + public string Garply => ctx.ReadText(1, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Corge + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string Grault + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string Garply + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + } + } + + public class @bar : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Corge = reader.Corge; + Grault = reader.Grault; + Garply = reader.Garply; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Corge = Corge; + writer.Grault = Grault; + writer.Garply = Garply; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Corge + { + get; + set; + } + + public string Grault + { + get; + set; + } + + public long Garply + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Corge => ctx.ReadDataInt(0UL, 0); + public string Grault => ctx.ReadText(0, ""); + public long Garply => ctx.ReadDataLong(64UL, 0L); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Corge + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string Grault + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public long Garply + { + get => this.ReadDataLong(64UL, 0L); + set => this.WriteData(64UL, value, 0L); + } + } + } + } + } + + public class TestInterleavedGroups : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Group1 = CapnpSerializable.Create(reader.Group1); + Group2 = CapnpSerializable.Create(reader.Group2); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Group1?.serialize(writer.Group1); + Group2?.serialize(writer.Group2); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1 Group1 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2 Group2 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @group1.READER Group1 => new @group1.READER(ctx); + public @group2.READER Group2 => new @group2.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(6, 6); + } + + public @group1.WRITER Group1 + { + get => Rewrap<@group1.WRITER>(); + } + + public @group2.WRITER Group2 + { + get => Rewrap<@group2.WRITER>(); + } + } + + public class @group1 : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Fred = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = CapnpSerializable.Create(reader.Corge); + break; + case WHICH.Fred: + Fred = reader.Fred; + break; + } + + Foo = reader.Foo; + Bar = reader.Bar; + Waldo = reader.Waldo; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = 0; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Fred: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux.Value; + break; + case WHICH.Corge: + Corge?.serialize(writer.Corge); + break; + case WHICH.Fred: + writer.Fred = Fred; + break; + } + + writer.Foo = Foo; + writer.Bar = Bar; + writer.Waldo = Waldo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Foo + { + get; + set; + } + + public ulong Bar + { + get; + set; + } + + public ushort? Qux + { + get => _which == WHICH.Qux ? (ushort? )_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1.@corge Corge + { + get => _which == WHICH.Corge ? (Capnproto_test.Capnp.Test.TestInterleavedGroups.@group1.@corge)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public string Waldo + { + get; + set; + } + + public string Fred + { + get => _which == WHICH.Fred ? (string)_content : null; + set + { + _which = WHICH.Fred; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(224U, (ushort)0); + public uint Foo => ctx.ReadDataUInt(0UL, 0U); + public ulong Bar => ctx.ReadDataULong(64UL, 0UL); + public ushort Qux => which == WHICH.Qux ? ctx.ReadDataUShort(192UL, (ushort)0) : default; + public @corge.READER Corge => which == WHICH.Corge ? new @corge.READER(ctx) : default; + public string Waldo => ctx.ReadText(0, ""); + public string Fred => which == WHICH.Fred ? ctx.ReadText(2, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(224U, (ushort)0); + set => this.WriteData(224U, (ushort)value, (ushort)0); + } + + public uint Foo + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public ulong Bar + { + get => this.ReadDataULong(64UL, 0UL); + set => this.WriteData(64UL, value, 0UL); + } + + public ushort Qux + { + get => which == WHICH.Qux ? this.ReadDataUShort(192UL, (ushort)0) : default; + set => this.WriteData(192UL, value, (ushort)0); + } + + public @corge.WRITER Corge + { + get => which == WHICH.Corge ? Rewrap<@corge.WRITER>() : default; + } + + public string Waldo + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string Fred + { + get => which == WHICH.Fred ? this.ReadText(2, "") : default; + set => this.WriteText(2, value, ""); + } + } + + public class @corge : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Grault = reader.Grault; + Garply = reader.Garply; + Plugh = reader.Plugh; + Xyzzy = reader.Xyzzy; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Grault = Grault; + writer.Garply = Garply; + writer.Plugh = Plugh; + writer.Xyzzy = Xyzzy; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Grault + { + get; + set; + } + + public ushort Garply + { + get; + set; + } + + public string Plugh + { + get; + set; + } + + public string Xyzzy + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Grault => ctx.ReadDataULong(256UL, 0UL); + public ushort Garply => ctx.ReadDataUShort(192UL, (ushort)0); + public string Plugh => ctx.ReadText(2, ""); + public string Xyzzy => ctx.ReadText(4, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong Grault + { + get => this.ReadDataULong(256UL, 0UL); + set => this.WriteData(256UL, value, 0UL); + } + + public ushort Garply + { + get => this.ReadDataUShort(192UL, (ushort)0); + set => this.WriteData(192UL, value, (ushort)0); + } + + public string Plugh + { + get => this.ReadText(2, ""); + set => this.WriteText(2, value, ""); + } + + public string Xyzzy + { + get => this.ReadText(4, ""); + set => this.WriteText(4, value, ""); + } + } + } + } + + public class @group2 : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Fred = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = CapnpSerializable.Create(reader.Corge); + break; + case WHICH.Fred: + Fred = reader.Fred; + break; + } + + Foo = reader.Foo; + Bar = reader.Bar; + Waldo = reader.Waldo; + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = 0; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Fred: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux.Value; + break; + case WHICH.Corge: + Corge?.serialize(writer.Corge); + break; + case WHICH.Fred: + writer.Fred = Fred; + break; + } + + writer.Foo = Foo; + writer.Bar = Bar; + writer.Waldo = Waldo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Foo + { + get; + set; + } + + public ulong Bar + { + get; + set; + } + + public ushort? Qux + { + get => _which == WHICH.Qux ? (ushort? )_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2.@corge Corge + { + get => _which == WHICH.Corge ? (Capnproto_test.Capnp.Test.TestInterleavedGroups.@group2.@corge)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public string Waldo + { + get; + set; + } + + public string Fred + { + get => _which == WHICH.Fred ? (string)_content : null; + set + { + _which = WHICH.Fred; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(240U, (ushort)0); + public uint Foo => ctx.ReadDataUInt(32UL, 0U); + public ulong Bar => ctx.ReadDataULong(128UL, 0UL); + public ushort Qux => which == WHICH.Qux ? ctx.ReadDataUShort(208UL, (ushort)0) : default; + public @corge.READER Corge => which == WHICH.Corge ? new @corge.READER(ctx) : default; + public string Waldo => ctx.ReadText(1, ""); + public string Fred => which == WHICH.Fred ? ctx.ReadText(3, "") : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(240U, (ushort)0); + set => this.WriteData(240U, (ushort)value, (ushort)0); + } + + public uint Foo + { + get => this.ReadDataUInt(32UL, 0U); + set => this.WriteData(32UL, value, 0U); + } + + public ulong Bar + { + get => this.ReadDataULong(128UL, 0UL); + set => this.WriteData(128UL, value, 0UL); + } + + public ushort Qux + { + get => which == WHICH.Qux ? this.ReadDataUShort(208UL, (ushort)0) : default; + set => this.WriteData(208UL, value, (ushort)0); + } + + public @corge.WRITER Corge + { + get => which == WHICH.Corge ? Rewrap<@corge.WRITER>() : default; + } + + public string Waldo + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + + public string Fred + { + get => which == WHICH.Fred ? this.ReadText(3, "") : default; + set => this.WriteText(3, value, ""); + } + } + + public class @corge : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Grault = reader.Grault; + Garply = reader.Garply; + Plugh = reader.Plugh; + Xyzzy = reader.Xyzzy; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Grault = Grault; + writer.Garply = Garply; + writer.Plugh = Plugh; + writer.Xyzzy = Xyzzy; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong Grault + { + get; + set; + } + + public ushort Garply + { + get; + set; + } + + public string Plugh + { + get; + set; + } + + public string Xyzzy + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong Grault => ctx.ReadDataULong(320UL, 0UL); + public ushort Garply => ctx.ReadDataUShort(208UL, (ushort)0); + public string Plugh => ctx.ReadText(3, ""); + public string Xyzzy => ctx.ReadText(5, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public ulong Grault + { + get => this.ReadDataULong(320UL, 0UL); + set => this.WriteData(320UL, value, 0UL); + } + + public ushort Garply + { + get => this.ReadDataUShort(208UL, (ushort)0); + set => this.WriteData(208UL, value, (ushort)0); + } + + public string Plugh + { + get => this.ReadText(3, ""); + set => this.WriteText(3, value, ""); + } + + public string Xyzzy + { + get => this.ReadText(5, ""); + set => this.WriteText(5, value, ""); + } + } + } + } + } + + public class TestUnionDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S16s8s64s8Set = CapnpSerializable.Create(reader.S16s8s64s8Set); + S0sps1s32Set = CapnpSerializable.Create(reader.S0sps1s32Set); + Unnamed1 = CapnpSerializable.Create(reader.Unnamed1); + Unnamed2 = CapnpSerializable.Create(reader.Unnamed2); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + S16s8s64s8Set?.serialize(writer.S16s8s64s8Set); + S0sps1s32Set?.serialize(writer.S0sps1s32Set); + Unnamed1?.serialize(writer.Unnamed1); + Unnamed2?.serialize(writer.Unnamed2); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + S16s8s64s8Set = S16s8s64s8Set ?? new Capnproto_test.Capnp.Test.TestUnion() + {Union0 = new Capnproto_test.Capnp.Test.TestUnion.@union0() + {}, Union1 = new Capnproto_test.Capnp.Test.TestUnion.@union1() + {}, Union2 = new Capnproto_test.Capnp.Test.TestUnion.@union2() + {}, Union3 = new Capnproto_test.Capnp.Test.TestUnion.@union3() + {}, Bit0 = false, Bit2 = false, Bit3 = false, Bit4 = false, Bit5 = false, Bit6 = false, Bit7 = false, Byte0 = 0}; + S0sps1s32Set = S0sps1s32Set ?? new Capnproto_test.Capnp.Test.TestUnion() + {Union0 = new Capnproto_test.Capnp.Test.TestUnion.@union0() + {}, Union1 = new Capnproto_test.Capnp.Test.TestUnion.@union1() + {}, Union2 = new Capnproto_test.Capnp.Test.TestUnion.@union2() + {}, Union3 = new Capnproto_test.Capnp.Test.TestUnion.@union3() + {}, Bit0 = false, Bit2 = false, Bit3 = false, Bit4 = false, Bit5 = false, Bit6 = false, Bit7 = false, Byte0 = 0}; + Unnamed1 = Unnamed1 ?? new Capnproto_test.Capnp.Test.TestUnnamedUnion() + {Before = null, Middle = 0, After = null}; + Unnamed2 = Unnamed2 ?? new Capnproto_test.Capnp.Test.TestUnnamedUnion() + {Before = "foo", Middle = 0, After = "bar"}; + } + + public Capnproto_test.Capnp.Test.TestUnion S16s8s64s8Set + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnion S0sps1s32Set + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion Unnamed1 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion Unnamed2 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestUnion.READER S16s8s64s8Set => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestUnion.READER.create); + public Capnproto_test.Capnp.Test.TestUnion.READER S0sps1s32Set => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestUnion.READER.create); + public Capnproto_test.Capnp.Test.TestUnnamedUnion.READER Unnamed1 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestUnnamedUnion.READER.create); + public Capnproto_test.Capnp.Test.TestUnnamedUnion.READER Unnamed2 => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestUnnamedUnion.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public Capnproto_test.Capnp.Test.TestUnion.WRITER S16s8s64s8Set + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestUnion.WRITER S0sps1s32Set + { + get => BuildPointer(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER Unnamed1 + { + get => BuildPointer(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestUnnamedUnion.WRITER Unnamed2 + { + get => BuildPointer(3); + set => Link(3, value); + } + } + } + + public class TestNestedTypes : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TheNestedStruct = CapnpSerializable.Create(reader.TheNestedStruct); + OuterNestedEnum = reader.OuterNestedEnum; + InnerNestedEnum = reader.InnerNestedEnum; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + TheNestedStruct?.serialize(writer.TheNestedStruct); + writer.OuterNestedEnum = OuterNestedEnum; + writer.InnerNestedEnum = InnerNestedEnum; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct TheNestedStruct + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum.bar; + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum.quux; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.READER TheNestedStruct => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.READER.create); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)ctx.ReadDataUShort(0UL, (ushort)1); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)ctx.ReadDataUShort(16UL, (ushort)2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.WRITER TheNestedStruct + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)this.ReadDataUShort(0UL, (ushort)1); + set => this.WriteData(0UL, (ushort)value, (ushort)1); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)this.ReadDataUShort(16UL, (ushort)2); + set => this.WriteData(16UL, (ushort)value, (ushort)2); + } + } + + public enum NestedEnum : ushort + { + foo, + bar + } + + public class NestedStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + OuterNestedEnum = reader.OuterNestedEnum; + InnerNestedEnum = reader.InnerNestedEnum; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.OuterNestedEnum = OuterNestedEnum; + writer.InnerNestedEnum = InnerNestedEnum; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum.bar; + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum.quux; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)ctx.ReadDataUShort(0UL, (ushort)1); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)ctx.ReadDataUShort(16UL, (ushort)2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)this.ReadDataUShort(0UL, (ushort)1); + set => this.WriteData(0UL, (ushort)value, (ushort)1); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)this.ReadDataUShort(16UL, (ushort)2); + set => this.WriteData(16UL, (ushort)value, (ushort)2); + } + } + + public enum NestedEnum : ushort + { + baz, + qux, + quux + } + } + } + + public class TestUsing : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + InnerNestedEnum = reader.InnerNestedEnum; + OuterNestedEnum = reader.OuterNestedEnum; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.InnerNestedEnum = InnerNestedEnum; + writer.OuterNestedEnum = OuterNestedEnum; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum.quux; + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get; + set; + } + + = Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum.bar; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)ctx.ReadDataUShort(0UL, (ushort)2); + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)ctx.ReadDataUShort(16UL, (ushort)1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum InnerNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedStruct.NestedEnum)this.ReadDataUShort(0UL, (ushort)2); + set => this.WriteData(0UL, (ushort)value, (ushort)2); + } + + public Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum OuterNestedEnum + { + get => (Capnproto_test.Capnp.Test.TestNestedTypes.NestedEnum)this.ReadDataUShort(16UL, (ushort)1); + set => this.WriteData(16UL, (ushort)value, (ushort)1); + } + } + } + + public class TestLists : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + List0 = reader.List0.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List1 = reader.List1.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List8 = reader.List8.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List16 = reader.List16.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List32 = reader.List32.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + List64 = reader.List64.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + ListP = reader.ListP.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + Int32ListList = reader.Int32ListList; + TextListList = reader.TextListList; + StructListList = reader.StructListList.ToReadOnlyList(_2 => _2.ToReadOnlyList(_ => CapnpSerializable.Create(_))); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.List0.Init(List0, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List1.Init(List1, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List8.Init(List8, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List16.Init(List16, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List32.Init(List32, (_s1, _v1) => _v1?.serialize(_s1)); + writer.List64.Init(List64, (_s1, _v1) => _v1?.serialize(_s1)); + writer.ListP.Init(ListP, (_s1, _v1) => _v1?.serialize(_s1)); + writer.Int32ListList.Init(Int32ListList, (_s2, _v2) => _s2.Init(_v2)); + writer.TextListList.Init(TextListList, (_s2, _v2) => _s2.Init(_v2)); + writer.StructListList.Init(StructListList, (_s2, _v2) => _s2.Init(_v2, (_s1, _v1) => _v1?.serialize(_s1))); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList List0 + { + get; + set; + } + + public IReadOnlyList List1 + { + get; + set; + } + + public IReadOnlyList List8 + { + get; + set; + } + + public IReadOnlyList List16 + { + get; + set; + } + + public IReadOnlyList List32 + { + get; + set; + } + + public IReadOnlyList List64 + { + get; + set; + } + + public IReadOnlyList ListP + { + get; + set; + } + + public IReadOnlyList> Int32ListList + { + get; + set; + } + + public IReadOnlyList> TextListList + { + get; + set; + } + + public IReadOnlyList> StructListList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList List0 => ctx.ReadList(0).Cast(Capnproto_test.Capnp.Test.TestLists.Struct0.READER.create); + public IReadOnlyList List1 => ctx.ReadList(1).Cast(Capnproto_test.Capnp.Test.TestLists.Struct1.READER.create); + public IReadOnlyList List8 => ctx.ReadList(2).Cast(Capnproto_test.Capnp.Test.TestLists.Struct8.READER.create); + public IReadOnlyList List16 => ctx.ReadList(3).Cast(Capnproto_test.Capnp.Test.TestLists.Struct16.READER.create); + public IReadOnlyList List32 => ctx.ReadList(4).Cast(Capnproto_test.Capnp.Test.TestLists.Struct32.READER.create); + public IReadOnlyList List64 => ctx.ReadList(5).Cast(Capnproto_test.Capnp.Test.TestLists.Struct64.READER.create); + public IReadOnlyList ListP => ctx.ReadList(6).Cast(Capnproto_test.Capnp.Test.TestLists.StructP.READER.create); + public IReadOnlyList> Int32ListList => ctx.ReadList(7).Cast(_0 => _0.RequireList().CastInt()); + public IReadOnlyList> TextListList => ctx.ReadList(8).Cast(_0 => _0.RequireList().CastText2()); + public IReadOnlyList> StructListList => ctx.ReadList(9).Cast(_0 => _0.RequireList().Cast(Capnproto_test.Capnp.Test.TestAllTypes.READER.create)); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 10); + } + + public ListOfStructsSerializer List0 + { + get => BuildPointer>(0); + set => Link(0, value); + } + + public ListOfStructsSerializer List1 + { + get => BuildPointer>(1); + set => Link(1, value); + } + + public ListOfStructsSerializer List8 + { + get => BuildPointer>(2); + set => Link(2, value); + } + + public ListOfStructsSerializer List16 + { + get => BuildPointer>(3); + set => Link(3, value); + } + + public ListOfStructsSerializer List32 + { + get => BuildPointer>(4); + set => Link(4, value); + } + + public ListOfStructsSerializer List64 + { + get => BuildPointer>(5); + set => Link(5, value); + } + + public ListOfStructsSerializer ListP + { + get => BuildPointer>(6); + set => Link(6, value); + } + + public ListOfPointersSerializer> Int32ListList + { + get => BuildPointer>>(7); + set => Link(7, value); + } + + public ListOfPointersSerializer TextListList + { + get => BuildPointer>(8); + set => Link(8, value); + } + + public ListOfPointersSerializer> StructListList + { + get => BuildPointer>>(9); + set => Link(9, value); + } + } + + public class Struct0 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Struct1 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool F => ctx.ReadDataBool(0UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public bool F + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + } + } + + public class Struct8 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public byte F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public byte F => ctx.ReadDataByte(0UL, (byte)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public byte F + { + get => this.ReadDataByte(0UL, (byte)0); + set => this.WriteData(0UL, value, (byte)0); + } + } + } + + public class Struct16 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ushort F => ctx.ReadDataUShort(0UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public ushort F + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + } + } + + public class Struct32 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint F => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint F + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + + public class Struct64 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong F => ctx.ReadDataULong(0UL, 0UL); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public ulong F + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + } + } + + public class StructP : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string F + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string F => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string F + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct0c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct1c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool F => ctx.ReadDataBool(0UL, false); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public bool F + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct8c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public byte F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public byte F => ctx.ReadDataByte(0UL, (byte)0); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public byte F + { + get => this.ReadDataByte(0UL, (byte)0); + set => this.WriteData(0UL, value, (byte)0); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct16c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ushort F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ushort F => ctx.ReadDataUShort(0UL, (ushort)0); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public ushort F + { + get => this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, value, (ushort)0); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct32c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint F => ctx.ReadDataUInt(0UL, 0U); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint F + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Struct64c : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong F + { + get; + set; + } + + public string Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public ulong F => ctx.ReadDataULong(0UL, 0UL); + public string Pad => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public ulong F + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + + public string Pad + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class StructPc : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + F = reader.F; + Pad = reader.Pad; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.F = F; + writer.Pad = Pad; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string F + { + get; + set; + } + + public ulong Pad + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string F => ctx.ReadText(0, ""); + public ulong Pad => ctx.ReadDataULong(0UL, 0UL); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public string F + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ulong Pad + { + get => this.ReadDataULong(0UL, 0UL); + set => this.WriteData(0UL, value, 0UL); + } + } + } + } + + public class TestFieldZeroIsBit : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Bit = reader.Bit; + SecondBit = reader.SecondBit; + ThirdField = reader.ThirdField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Bit = Bit; + writer.SecondBit = SecondBit; + writer.ThirdField = ThirdField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool Bit + { + get; + set; + } + + public bool SecondBit + { + get; + set; + } + + = true; + public byte ThirdField + { + get; + set; + } + + = 123; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool Bit => ctx.ReadDataBool(0UL, false); + public bool SecondBit => ctx.ReadDataBool(1UL, true); + public byte ThirdField => ctx.ReadDataByte(8UL, (byte)123); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public bool Bit + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public bool SecondBit + { + get => this.ReadDataBool(1UL, true); + set => this.WriteData(1UL, value, true); + } + + public byte ThirdField + { + get => this.ReadDataByte(8UL, (byte)123); + set => this.WriteData(8UL, value, (byte)123); + } + } + } + + public class TestListDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Lists = CapnpSerializable.Create(reader.Lists); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Lists?.serialize(writer.Lists); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + Lists = Lists ?? new Capnproto_test.Capnp.Test.TestLists() + {List0 = new Capnproto_test.Capnp.Test.TestLists.Struct0[]{new Capnproto_test.Capnp.Test.TestLists.Struct0() + {}, new Capnproto_test.Capnp.Test.TestLists.Struct0() + {}}, List1 = new Capnproto_test.Capnp.Test.TestLists.Struct1[]{new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = true}, new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = false}, new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = true}, new Capnproto_test.Capnp.Test.TestLists.Struct1() + {F = true}}, List8 = new Capnproto_test.Capnp.Test.TestLists.Struct8[]{new Capnproto_test.Capnp.Test.TestLists.Struct8() + {F = 123}, new Capnproto_test.Capnp.Test.TestLists.Struct8() + {F = 45}}, List16 = new Capnproto_test.Capnp.Test.TestLists.Struct16[]{new Capnproto_test.Capnp.Test.TestLists.Struct16() + {F = 12345}, new Capnproto_test.Capnp.Test.TestLists.Struct16() + {F = 6789}}, List32 = new Capnproto_test.Capnp.Test.TestLists.Struct32[]{new Capnproto_test.Capnp.Test.TestLists.Struct32() + {F = 123456789U}, new Capnproto_test.Capnp.Test.TestLists.Struct32() + {F = 234567890U}}, List64 = new Capnproto_test.Capnp.Test.TestLists.Struct64[]{new Capnproto_test.Capnp.Test.TestLists.Struct64() + {F = 1234567890123456UL}, new Capnproto_test.Capnp.Test.TestLists.Struct64() + {F = 2345678901234567UL}}, ListP = new Capnproto_test.Capnp.Test.TestLists.StructP[]{new Capnproto_test.Capnp.Test.TestLists.StructP() + {F = "foo"}, new Capnproto_test.Capnp.Test.TestLists.StructP() + {F = "bar"}}, Int32ListList = new IReadOnlyList[]{new int[]{1, 2, 3}, new int[]{4, 5}, new int[]{12341234}}, TextListList = new IReadOnlyList[]{new string[]{"foo", "bar"}, new string[]{"baz"}, new string[]{"qux", "corge"}}, StructListList = new IReadOnlyList[]{new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 123, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 456, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}, new Capnproto_test.Capnp.Test.TestAllTypes[]{new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 0, Int32Field = 789, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}}}}; + } + + public Capnproto_test.Capnp.Test.TestLists Lists + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestLists.READER Lists => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestLists.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestLists.WRITER Lists + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class TestLateUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = reader.Foo; + Bar = reader.Bar; + Baz = reader.Baz; + TheUnion = CapnpSerializable.Create(reader.TheUnion); + AnotherUnion = CapnpSerializable.Create(reader.AnotherUnion); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo = Foo; + writer.Bar = Bar; + writer.Baz = Baz; + TheUnion?.serialize(writer.TheUnion); + AnotherUnion?.serialize(writer.AnotherUnion); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Foo + { + get; + set; + } + + public string Bar + { + get; + set; + } + + public short Baz + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestLateUnion.@theUnion TheUnion + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestLateUnion.@anotherUnion AnotherUnion + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Foo => ctx.ReadDataInt(0UL, 0); + public string Bar => ctx.ReadText(0, ""); + public short Baz => ctx.ReadDataShort(32UL, (short)0); + public @theUnion.READER TheUnion => new @theUnion.READER(ctx); + public @anotherUnion.READER AnotherUnion => new @anotherUnion.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 3); + } + + public int Foo + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string Bar + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public short Baz + { + get => this.ReadDataShort(32UL, (short)0); + set => this.WriteData(32UL, value, (short)0); + } + + public @theUnion.WRITER TheUnion + { + get => Rewrap<@theUnion.WRITER>(); + } + + public @anotherUnion.WRITER AnotherUnion + { + get => Rewrap<@anotherUnion.WRITER>(); + } + } + + public class @theUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Grault = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = reader.Corge; + break; + case WHICH.Grault: + Grault = reader.Grault; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = null; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Grault: + _content = 0F; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux; + break; + case WHICH.Corge: + writer.Corge.Init(Corge); + break; + case WHICH.Grault: + writer.Grault = Grault.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Qux + { + get => _which == WHICH.Qux ? (string)_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public IReadOnlyList Corge + { + get => _which == WHICH.Corge ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public float? Grault + { + get => _which == WHICH.Grault ? (float? )_content : null; + set + { + _which = WHICH.Grault; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public string Qux => which == WHICH.Qux ? ctx.ReadText(1, "") : default; + public IReadOnlyList Corge => which == WHICH.Corge ? ctx.ReadList(1).CastInt() : default; + public float Grault => which == WHICH.Grault ? ctx.ReadDataFloat(64UL, 0F) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public string Qux + { + get => which == WHICH.Qux ? this.ReadText(1, "") : default; + set => this.WriteText(1, value, ""); + } + + public ListOfPrimitivesSerializer Corge + { + get => which == WHICH.Corge ? BuildPointer>(1) : default; + set => Link(1, value); + } + + public float Grault + { + get => which == WHICH.Grault ? this.ReadDataFloat(64UL, 0F) : default; + set => this.WriteData(64UL, value, 0F); + } + } + } + + public class @anotherUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + Qux = 0, + Corge = 1, + Grault = 2, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Qux: + Qux = reader.Qux; + break; + case WHICH.Corge: + Corge = reader.Corge; + break; + case WHICH.Grault: + Grault = reader.Grault; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Qux: + _content = null; + break; + case WHICH.Corge: + _content = null; + break; + case WHICH.Grault: + _content = 0F; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Qux: + writer.Qux = Qux; + break; + case WHICH.Corge: + writer.Corge.Init(Corge); + break; + case WHICH.Grault: + writer.Grault = Grault.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Qux + { + get => _which == WHICH.Qux ? (string)_content : null; + set + { + _which = WHICH.Qux; + _content = value; + } + } + + public IReadOnlyList Corge + { + get => _which == WHICH.Corge ? (IReadOnlyList)_content : null; + set + { + _which = WHICH.Corge; + _content = value; + } + } + + public float? Grault + { + get => _which == WHICH.Grault ? (float? )_content : null; + set + { + _which = WHICH.Grault; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(96U, (ushort)0); + public string Qux => which == WHICH.Qux ? ctx.ReadText(2, "") : default; + public IReadOnlyList Corge => which == WHICH.Corge ? ctx.ReadList(2).CastInt() : default; + public float Grault => which == WHICH.Grault ? ctx.ReadDataFloat(128UL, 0F) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(96U, (ushort)0); + set => this.WriteData(96U, (ushort)value, (ushort)0); + } + + public string Qux + { + get => which == WHICH.Qux ? this.ReadText(2, "") : default; + set => this.WriteText(2, value, ""); + } + + public ListOfPrimitivesSerializer Corge + { + get => which == WHICH.Corge ? BuildPointer>(2) : default; + set => Link(2, value); + } + + public float Grault + { + get => which == WHICH.Grault ? this.ReadDataFloat(128UL, 0F) : default; + set => this.WriteData(128UL, value, 0F); + } + } + } + } + + public class TestOldVersion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Old1 = reader.Old1; + Old2 = reader.Old2; + Old3 = CapnpSerializable.Create(reader.Old3); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Old1 = Old1; + writer.Old2 = Old2; + Old3?.serialize(writer.Old3); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public long Old1 + { + get; + set; + } + + public string Old2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestOldVersion Old3 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public long Old1 => ctx.ReadDataLong(0UL, 0L); + public string Old2 => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestOldVersion.READER Old3 => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestOldVersion.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public long Old1 + { + get => this.ReadDataLong(0UL, 0L); + set => this.WriteData(0UL, value, 0L); + } + + public string Old2 + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestOldVersion.WRITER Old3 + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class TestNewVersion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Old1 = reader.Old1; + Old2 = reader.Old2; + Old3 = CapnpSerializable.Create(reader.Old3); + New1 = reader.New1; + New2 = reader.New2; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Old1 = Old1; + writer.Old2 = Old2; + Old3?.serialize(writer.Old3); + writer.New1 = New1; + writer.New2 = New2; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + New2 = New2 ?? "baz"; + } + + public long Old1 + { + get; + set; + } + + public string Old2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNewVersion Old3 + { + get; + set; + } + + public long New1 + { + get; + set; + } + + = 987L; + public string New2 + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public long Old1 => ctx.ReadDataLong(0UL, 0L); + public string Old2 => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestNewVersion.READER Old3 => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestNewVersion.READER.create); + public long New1 => ctx.ReadDataLong(64UL, 987L); + public string New2 => ctx.ReadText(2, "baz"); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 3); + } + + public long Old1 + { + get => this.ReadDataLong(0UL, 0L); + set => this.WriteData(0UL, value, 0L); + } + + public string Old2 + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestNewVersion.WRITER Old3 + { + get => BuildPointer(1); + set => Link(1, value); + } + + public long New1 + { + get => this.ReadDataLong(64UL, 987L); + set => this.WriteData(64UL, value, 987L); + } + + public string New2 + { + get => this.ReadText(2, "baz"); + set => this.WriteText(2, value, "baz"); + } + } + } + + public class TestOldUnionVersion : ICapnpSerializable + { + public enum WHICH : ushort + { + A = 0, + B = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.A: + which = reader.which; + break; + case WHICH.B: + B = reader.B; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.A: + break; + case WHICH.B: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.A: + break; + case WHICH.B: + writer.B = B.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong? B + { + get => _which == WHICH.B ? (ulong? )_content : null; + set + { + _which = WHICH.B; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public ulong B => which == WHICH.B ? ctx.ReadDataULong(64UL, 0UL) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(2, 0); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public ulong B + { + get => which == WHICH.B ? this.ReadDataULong(64UL, 0UL) : default; + set => this.WriteData(64UL, value, 0UL); + } + } + } + + public class TestNewUnionVersion : ICapnpSerializable + { + public enum WHICH : ushort + { + A = 0, + B = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.A: + A = CapnpSerializable.Create(reader.A); + break; + case WHICH.B: + B = reader.B; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.A: + _content = null; + break; + case WHICH.B: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.A: + A?.serialize(writer.A); + break; + case WHICH.B: + writer.B = B.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNewUnionVersion.@a A + { + get => _which == WHICH.A ? (Capnproto_test.Capnp.Test.TestNewUnionVersion.@a)_content : null; + set + { + _which = WHICH.A; + _content = value; + } + } + + public ulong? B + { + get => _which == WHICH.B ? (ulong? )_content : null; + set + { + _which = WHICH.B; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public @a.READER A => which == WHICH.A ? new @a.READER(ctx) : default; + public ulong B => which == WHICH.B ? ctx.ReadDataULong(64UL, 0UL) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(3, 0); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public @a.WRITER A + { + get => which == WHICH.A ? Rewrap<@a.WRITER>() : default; + } + + public ulong B + { + get => which == WHICH.B ? this.ReadDataULong(64UL, 0UL) : default; + set => this.WriteData(64UL, value, 0UL); + } + } + + public class @a : ICapnpSerializable + { + public enum WHICH : ushort + { + A0 = 0, + A1 = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.A0: + which = reader.which; + break; + case WHICH.A1: + A1 = reader.A1; + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.A0: + break; + case WHICH.A1: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.A0: + break; + case WHICH.A1: + writer.A1 = A1.Value; + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public ulong? A1 + { + get => _which == WHICH.A1 ? (ulong? )_content : null; + set + { + _which = WHICH.A1; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(64U, (ushort)0); + public ulong A1 => which == WHICH.A1 ? ctx.ReadDataULong(128UL, 0UL) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(64U, (ushort)0); + set => this.WriteData(64U, (ushort)value, (ushort)0); + } + + public ulong A1 + { + get => which == WHICH.A1 ? this.ReadDataULong(128UL, 0UL) : default; + set => this.WriteData(128UL, value, 0UL); + } + } + } + } + + public class TestStructUnion : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Un = CapnpSerializable.Create(reader.Un); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Un?.serialize(writer.Un); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestStructUnion.@un Un + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public @un.READER Un => new @un.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public @un.WRITER Un + { + get => Rewrap<@un.WRITER>(); + } + } + + public class @un : ICapnpSerializable + { + public enum WHICH : ushort + { + Struct = 0, + Object = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Struct: + Struct = CapnpSerializable.Create(reader.Struct); + break; + case WHICH.Object: + Object = CapnpSerializable.Create(reader.Object); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Struct: + _content = null; + break; + case WHICH.Object: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Struct: + Struct?.serialize(writer.Struct); + break; + case WHICH.Object: + Object?.serialize(writer.Object); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct Struct + { + get => _which == WHICH.Struct ? (Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct)_content : null; + set + { + _which = WHICH.Struct; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestAnyPointer Object + { + get => _which == WHICH.Object ? (Capnproto_test.Capnp.Test.TestAnyPointer)_content : null; + set + { + _which = WHICH.Object; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct.READER Struct => which == WHICH.Struct ? ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct.READER.create) : default; + public Capnproto_test.Capnp.Test.TestAnyPointer.READER Object => which == WHICH.Object ? ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestAnyPointer.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public Capnproto_test.Capnp.Test.TestStructUnion.SomeStruct.WRITER Struct + { + get => which == WHICH.Struct ? BuildPointer(0) : default; + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestAnyPointer.WRITER Object + { + get => which == WHICH.Object ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class SomeStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + SomeText = reader.SomeText; + MoreText = reader.MoreText; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.SomeText = SomeText; + writer.MoreText = MoreText; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string SomeText + { + get; + set; + } + + public string MoreText + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string SomeText => ctx.ReadText(0, ""); + public string MoreText => ctx.ReadText(1, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string SomeText + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string MoreText + { + get => this.ReadText(1, ""); + set => this.WriteText(1, value, ""); + } + } + } + } + + public class TestPrintInlineStructs : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + SomeText = reader.SomeText; + StructList = reader.StructList.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.SomeText = SomeText; + writer.StructList.Init(StructList, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string SomeText + { + get; + set; + } + + public IReadOnlyList StructList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string SomeText => ctx.ReadText(0, ""); + public IReadOnlyList StructList => ctx.ReadList(1).Cast(Capnproto_test.Capnp.Test.TestPrintInlineStructs.InlineStruct.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string SomeText + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public ListOfStructsSerializer StructList + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + + public class InlineStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Int32Field = reader.Int32Field; + TextField = reader.TextField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Int32Field = Int32Field; + writer.TextField = TextField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Int32Field + { + get; + set; + } + + public string TextField + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Int32Field => ctx.ReadDataInt(0UL, 0); + public string TextField => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public int Int32Field + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string TextField + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + } + + public class TestWholeFloatDefault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Field = reader.Field; + BigField = reader.BigField; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Field = Field; + writer.BigField = BigField; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public float Field + { + get; + set; + } + + = 123F; + public float BigField + { + get; + set; + } + + = 2E+30F; + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public float Field => ctx.ReadDataFloat(0UL, 123F); + public float BigField => ctx.ReadDataFloat(32UL, 2E+30F); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public float Field + { + get => this.ReadDataFloat(0UL, 123F); + set => this.WriteData(0UL, value, 123F); + } + + public float BigField + { + get => this.ReadDataFloat(32UL, 2E+30F); + set => this.WriteData(32UL, value, 2E+30F); + } + } + } + + public class TestGenerics : ICapnpSerializable where TFoo : class where TBar : class + { + public enum WHICH : ushort + { + Uv = 0, + Ug = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Uv: + which = reader.which; + break; + case WHICH.Ug: + Ug = CapnpSerializable.Create.@ug>(reader.Ug); + break; + } + + Foo = CapnpSerializable.Create(reader.Foo); + Rev = CapnpSerializable.Create>(reader.Rev); + List = reader.List.ToReadOnlyList(_ => CapnpSerializable.Create.Inner>(_)); + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Uv: + break; + case WHICH.Ug: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Uv: + break; + case WHICH.Ug: + Ug?.serialize(writer.Ug); + break; + } + + writer.Foo.SetObject(Foo); + Rev?.serialize(writer.Rev); + writer.List.Init(List, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Rev + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.@ug Ug + { + get => _which == WHICH.Ug ? (Capnproto_test.Capnp.Test.TestGenerics.@ug)_content : null; + set + { + _which = WHICH.Ug; + _content = value; + } + } + + public IReadOnlyList.Inner> List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public DeserializerState Foo => ctx.StructReadPointer(0); + public Capnproto_test.Capnp.Test.TestGenerics.READER Rev => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public @ug.READER Ug => which == WHICH.Ug ? new @ug.READER(ctx) : default; + public IReadOnlyList.Inner.READER> List => ctx.ReadList(2).Cast(Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 3); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Rev + { + get => BuildPointer.WRITER>(1); + set => Link(1, value); + } + + public @ug.WRITER Ug + { + get => which == WHICH.Ug ? Rewrap<@ug.WRITER>() : default; + } + + public ListOfStructsSerializer.Inner.WRITER> List + { + get => BuildPointer.Inner.WRITER>>(2); + set => Link(2, value); + } + } + + public class @ug : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Ugfoo = reader.Ugfoo; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Ugfoo = Ugfoo; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int Ugfoo + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int Ugfoo => ctx.ReadDataInt(32UL, 0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public int Ugfoo + { + get => this.ReadDataInt(32UL, 0); + set => this.WriteData(32UL, value, 0); + } + } + } + + public class Inner : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public TBar Bar + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class Inner2 : ICapnpSerializable where TBaz : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Bar = CapnpSerializable.Create(reader.Bar); + Baz = CapnpSerializable.Create(reader.Baz); + InnerBound = CapnpSerializable.Create.Inner>(reader.InnerBound); + InnerUnbound = CapnpSerializable.Create.Inner>(reader.InnerUnbound); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Bar.SetObject(Bar); + writer.Baz.SetObject(Baz); + InnerBound?.serialize(writer.InnerBound); + InnerUnbound?.serialize(writer.InnerUnbound); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TBar Bar + { + get; + set; + } + + public TBaz Baz + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner InnerBound + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner InnerUnbound + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Bar => ctx.StructReadPointer(0); + public DeserializerState Baz => ctx.StructReadPointer(1); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER InnerBound => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER InnerUnbound => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Baz + { + get => BuildPointer(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER InnerBound + { + get => BuildPointer.Inner.WRITER>(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER InnerUnbound + { + get => BuildPointer.Inner.WRITER>(3); + set => Link(3, value); + } + } + + public class DeepNest : ICapnpSerializable where TQux : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + Baz = CapnpSerializable.Create(reader.Baz); + Qux = CapnpSerializable.Create(reader.Qux); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + writer.Baz.SetObject(Baz); + writer.Qux.SetObject(Qux); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public TBar Bar + { + get; + set; + } + + public TBaz Baz + { + get; + set; + } + + public TQux Qux + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + public DeserializerState Baz => ctx.StructReadPointer(2); + public DeserializerState Qux => ctx.StructReadPointer(3); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + + public DynamicSerializerState Baz + { + get => BuildPointer(2); + set => Link(2, value); + } + + public DynamicSerializerState Qux + { + get => BuildPointer(3); + set => Link(3, value); + } + } + + [Proxy(typeof(DeepNestInterfaceProxy<>)), Skeleton(typeof(DeepNestInterfaceSkeleton<>))] + public interface IDeepNestInterface : IDisposable + { + Task Call(CancellationToken cancellationToken_ = default); + } + + public class DeepNestInterfaceProxy : Proxy, IDeepNestInterface where TQuux : class + { + public async Task Call(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc.Inner2.DeepNest.DeepNestInterface.Params_call.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestGenerics.Inner2.DeepNest.DeepNestInterface.Params_call() + {}; + arg_.serialize(in_); + var d_ = await Call(9816138025992274567UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create.Inner2.DeepNest.DeepNestInterface.Result_call>(d_); + return; + } + } + + public class DeepNestInterfaceSkeleton : Skeleton> where TQuux : class + { + public DeepNestInterfaceSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 9816138025992274567UL; + async Task Call(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Call(cancellationToken_); + var s_ = SerializerState.CreateForRpc.Inner2.DeepNest.DeepNestInterface.Result_call.WRITER>(); + return s_; + } + } + + public static class DeepNestInterface + where TQuux : class + { + public class Params_call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + } + } + + [Proxy(typeof(InterfaceProxy<>)), Skeleton(typeof(InterfaceSkeleton<>))] + public interface IInterface : IDisposable + { + Task<(TQux, Capnproto_test.Capnp.Test.TestGenerics)> Call(Capnproto_test.Capnp.Test.TestGenerics.Inner2 arg_, CancellationToken cancellationToken_ = default); + } + + public class InterfaceProxy : Proxy, IInterface where TQux : class + { + public Task<(TQux, Capnproto_test.Capnp.Test.TestGenerics)> Call(Capnproto_test.Capnp.Test.TestGenerics.Inner2 arg_, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc.Inner2.WRITER>(); + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(14548678385738242652UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create.Interface.Result_call>(d_); + return (r_.Qux, r_.Gen); + } + + ); + } + } + + public class InterfaceSkeleton : Skeleton> where TQux : class + { + public InterfaceSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 14548678385738242652UL; + Task Call(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.Call(CapnpSerializable.Create.Inner2>(d_), cancellationToken_), (qux, gen) => + { + var s_ = SerializerState.CreateForRpc.Interface.Result_call.WRITER>(); + var r_ = new Capnproto_test.Capnp.Test.TestGenerics.Interface.Result_call{Qux = qux, Gen = gen}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class Interface + where TQux : class + { + public class Result_call : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Qux = CapnpSerializable.Create(reader.Qux); + Gen = CapnpSerializable.Create>(reader.Gen); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Qux.SetObject(Qux); + Gen?.serialize(writer.Gen); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TQux Qux + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Gen + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Qux => ctx.StructReadPointer(0); + public Capnproto_test.Capnp.Test.TestGenerics.READER Gen => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Qux + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Gen + { + get => BuildPointer.WRITER>(1); + set => Link(1, value); + } + } + } + } + + public class UseAliases : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Inner = CapnpSerializable.Create.Inner>(reader.Inner); + Inner2 = CapnpSerializable.Create.Inner2>(reader.Inner2); + Inner2Bind = CapnpSerializable.Create.Inner2>(reader.Inner2Bind); + Inner2Text = CapnpSerializable.Create.Inner2>(reader.Inner2Text); + RevFoo = CapnpSerializable.Create(reader.RevFoo); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + Inner?.serialize(writer.Inner); + Inner2?.serialize(writer.Inner2); + Inner2Bind?.serialize(writer.Inner2Bind); + Inner2Text?.serialize(writer.Inner2Text); + writer.RevFoo.SetObject(RevFoo); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner Inner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2Bind + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2Text + { + get; + set; + } + + public TBar RevFoo + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER Inner => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2Bind => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2Text => ctx.ReadStruct(4, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public DeserializerState RevFoo => ctx.StructReadPointer(5); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 6); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER Inner + { + get => BuildPointer.Inner.WRITER>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2 + { + get => BuildPointer.Inner2.WRITER>(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2Bind + { + get => BuildPointer.Inner2.WRITER>(3); + set => Link(3, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2Text + { + get => BuildPointer.Inner2.WRITER>(4); + set => Link(4, value); + } + + public DynamicSerializerState RevFoo + { + get => BuildPointer(5); + set => Link(5, value); + } + } + } + } + + public class TestGenericsWrapper : ICapnpSerializable where TFoo : class where TBar : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Value = CapnpSerializable.Create>(reader.Value); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Value?.serialize(writer.Value); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGenerics Value + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestGenerics.READER Value => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Value + { + get => BuildPointer.WRITER>(0); + set => Link(0, value); + } + } + } + + public class TestGenericsWrapper2 : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Value = CapnpSerializable.Create>(reader.Value); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Value?.serialize(writer.Value); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper Value + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestGenericsWrapper.READER Value => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenericsWrapper.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper.WRITER Value + { + get => BuildPointer.WRITER>(0); + set => Link(0, value); + } + } + } + + [Proxy(typeof(TestImplicitMethodParamsProxy)), Skeleton(typeof(TestImplicitMethodParamsSkeleton))] + public interface ITestImplicitMethodParams : IDisposable + { + Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class; + } + + public class TestImplicitMethodParamsProxy : Proxy, ITestImplicitMethodParams + { + public Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class + { + var in_ = SerializerState.CreateForRpc.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestImplicitMethodParams.Params_call() + {Foo = foo, Bar = bar}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(10058534285777328794UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create>(d_); + return r_; + } + + ); + } + } + + public class TestImplicitMethodParamsSkeleton : Skeleton + { + public TestImplicitMethodParamsSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 10058534285777328794UL; + Task Call(DeserializerState d_, CancellationToken cancellationToken_) + where TT : class where TU : class + { + var in_ = CapnpSerializable.Create>(d_); + return Impatient.MaybeTailCall(Impl.Call(in_.Foo, in_.Bar, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc.WRITER>(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestImplicitMethodParams + { + public class Params_call : ICapnpSerializable where TT : class where TU : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TT Foo + { + get; + set; + } + + public TU Bar + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + } + + [Proxy(typeof(TestImplicitMethodParamsInGenericProxy<>)), Skeleton(typeof(TestImplicitMethodParamsInGenericSkeleton<>))] + public interface ITestImplicitMethodParamsInGeneric : IDisposable + { + Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class; + } + + public class TestImplicitMethodParamsInGenericProxy : Proxy, ITestImplicitMethodParamsInGeneric where TV : class + { + public Task> Call(TT foo, TU bar, CancellationToken cancellationToken_ = default) + where TT : class where TU : class + { + var in_ = SerializerState.CreateForRpc.Params_call.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestImplicitMethodParamsInGeneric.Params_call() + {Foo = foo, Bar = bar}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(16112979978201007305UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create>(d_); + return r_; + } + + ); + } + } + + public class TestImplicitMethodParamsInGenericSkeleton : Skeleton> where TV : class + { + public TestImplicitMethodParamsInGenericSkeleton() + { + SetMethodTable(Call); + } + + public override ulong InterfaceId => 16112979978201007305UL; + Task Call(DeserializerState d_, CancellationToken cancellationToken_) + where TT : class where TU : class + { + var in_ = CapnpSerializable.Create.Params_call>(d_); + return Impatient.MaybeTailCall(Impl.Call(in_.Foo, in_.Bar, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc.WRITER>(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestImplicitMethodParamsInGeneric + where TV : class + { + public class Params_call : ICapnpSerializable where TT : class where TU : class + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Foo = CapnpSerializable.Create(reader.Foo); + Bar = CapnpSerializable.Create(reader.Bar); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Foo.SetObject(Foo); + writer.Bar.SetObject(Bar); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TT Foo + { + get; + set; + } + + public TU Bar + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Foo => ctx.StructReadPointer(0); + public DeserializerState Bar => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public DynamicSerializerState Foo + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + } + + public class TestGenericsUnion : ICapnpSerializable where TFoo : class where TBar : class + { + public enum WHICH : ushort + { + Foo = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.Foo: + Foo = CapnpSerializable.Create(reader.Foo); + break; + case WHICH.Bar: + Bar = CapnpSerializable.Create(reader.Bar); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.Foo: + _content = null; + break; + case WHICH.Bar: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.Foo: + writer.Foo.SetObject(Foo); + break; + case WHICH.Bar: + writer.Bar.SetObject(Bar); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TFoo Foo + { + get => _which == WHICH.Foo ? (TFoo)_content : null; + set + { + _which = WHICH.Foo; + _content = value; + } + } + + public TBar Bar + { + get => _which == WHICH.Bar ? (TBar)_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(0U, (ushort)0); + public DeserializerState Foo => which == WHICH.Foo ? ctx.StructReadPointer(0) : default; + public DeserializerState Bar => which == WHICH.Bar ? ctx.StructReadPointer(0) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(0U, (ushort)0); + set => this.WriteData(0U, (ushort)value, (ushort)0); + } + + public DynamicSerializerState Foo + { + get => which == WHICH.Foo ? BuildPointer(0) : default; + set => Link(0, value); + } + + public DynamicSerializerState Bar + { + get => which == WHICH.Bar ? BuildPointer(0) : default; + set => Link(0, value); + } + } + } + + public class TestUseGenerics : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Basic = CapnpSerializable.Create>(reader.Basic); + Inner = CapnpSerializable.Create.Inner>(reader.Inner); + Inner2 = CapnpSerializable.Create.Inner2>(reader.Inner2); + Unspecified = CapnpSerializable.Create>(reader.Unspecified); + UnspecifiedInner = CapnpSerializable.Create.Inner2>(reader.UnspecifiedInner); + Default = CapnpSerializable.Create>(reader.Default); + DefaultInner = CapnpSerializable.Create.Inner>(reader.DefaultInner); + DefaultUser = CapnpSerializable.Create(reader.DefaultUser); + Wrapper = CapnpSerializable.Create>(reader.Wrapper); + DefaultWrapper = CapnpSerializable.Create>(reader.DefaultWrapper); + DefaultWrapper2 = CapnpSerializable.Create(reader.DefaultWrapper2); + AliasFoo = CapnpSerializable.Create(reader.AliasFoo); + AliasInner = CapnpSerializable.Create.Inner>(reader.AliasInner); + AliasInner2 = CapnpSerializable.Create.Inner2>(reader.AliasInner2); + AliasInner2Bind = CapnpSerializable.Create.Inner2>>(reader.AliasInner2Bind); + AliasInner2Text = CapnpSerializable.Create.Inner2>(reader.AliasInner2Text); + AliasRev = reader.AliasRev; + UseAliases = CapnpSerializable.Create>.UseAliases>(reader.UseAliases); + Cap = CapnpSerializable.Create>(reader.Cap); + GenericCap = reader.GenericCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + Basic?.serialize(writer.Basic); + Inner?.serialize(writer.Inner); + Inner2?.serialize(writer.Inner2); + Unspecified?.serialize(writer.Unspecified); + UnspecifiedInner?.serialize(writer.UnspecifiedInner); + Default?.serialize(writer.Default); + DefaultInner?.serialize(writer.DefaultInner); + DefaultUser?.serialize(writer.DefaultUser); + Wrapper?.serialize(writer.Wrapper); + DefaultWrapper?.serialize(writer.DefaultWrapper); + DefaultWrapper2?.serialize(writer.DefaultWrapper2); + AliasFoo?.serialize(writer.AliasFoo); + AliasInner?.serialize(writer.AliasInner); + AliasInner2?.serialize(writer.AliasInner2); + AliasInner2Bind?.serialize(writer.AliasInner2Bind); + AliasInner2Text?.serialize(writer.AliasInner2Text); + writer.AliasRev = AliasRev; + UseAliases?.serialize(writer.UseAliases); + Cap?.serialize(writer.Cap); + writer.GenericCap = GenericCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + Default = Default ?? new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 321, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}; + DefaultInner = DefaultInner ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = "text"}; + DefaultUser = DefaultUser ?? new Capnproto_test.Capnp.Test.TestUseGenerics() + {Basic = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, Inner = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}, Inner2 = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, Unspecified = new Capnproto_test.Capnp.Test.TestGenerics() + {}, UnspecifiedInner = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, Default = new Capnproto_test.Capnp.Test.TestGenerics() + {}, DefaultInner = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}, DefaultUser = new Capnproto_test.Capnp.Test.TestUseGenerics() + {}, Wrapper = new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {}, DefaultWrapper = new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {}, DefaultWrapper2 = new Capnproto_test.Capnp.Test.TestGenericsWrapper2() + {}, AliasFoo = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, AliasInner = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}, AliasInner2 = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, AliasInner2Bind = new Capnproto_test.Capnp.Test.TestGenerics.Inner2>() + {}, AliasInner2Text = new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {}, AliasRev = null, UseAliases = new Capnproto_test.Capnp.Test.TestGenerics>.UseAliases() + {}, Cap = new Capnproto_test.Capnp.Test.TestGenerics() + {}}; + DefaultWrapper = DefaultWrapper ?? new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {Value = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 321, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}}; + DefaultWrapper2 = DefaultWrapper2 ?? new Capnproto_test.Capnp.Test.TestGenericsWrapper2() + {Value = new Capnproto_test.Capnp.Test.TestGenericsWrapper() + {Value = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = "text", Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 321, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Rev = new Capnproto_test.Capnp.Test.TestGenerics() + {}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}, List = new Capnproto_test.Capnp.Test.TestGenerics.Inner[]{}}}}; + AliasFoo = AliasFoo ?? new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}; + AliasInner = AliasInner ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}; + AliasInner2 = AliasInner2 ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}}; + AliasInner2Bind = AliasInner2Bind ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner2>() + {Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}, Baz = new uint[]{12U, 34U}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}}; + AliasInner2Text = AliasInner2Text ?? new Capnproto_test.Capnp.Test.TestGenerics.Inner2() + {Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new Capnproto_test.Capnp.Test.TestAnyPointer() + {}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics.Inner() + {}}; + AliasRev = AliasRev ?? "text"; + UseAliases = UseAliases ?? new Capnproto_test.Capnp.Test.TestGenerics>.UseAliases() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Inner = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, Inner2 = new Capnproto_test.Capnp.Test.TestGenerics>.Inner2() + {Bar = new uint[]{}, InnerBound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {}}, Inner2Bind = new Capnproto_test.Capnp.Test.TestGenerics>.Inner2() + {Bar = new uint[]{}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {}}, Inner2Text = new Capnproto_test.Capnp.Test.TestGenerics>.Inner2() + {Bar = new uint[]{}, Baz = "text", InnerBound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {Foo = new Capnproto_test.Capnp.Test.TestAllTypes() + {BoolField = false, Int8Field = 0, Int16Field = 123, Int32Field = 0, Int64Field = 0L, UInt8Field = 0, UInt16Field = 0, UInt32Field = 0U, UInt64Field = 0UL, Float32Field = 0F, Float64Field = 0, TextField = null, DataField = new byte[]{}, StructField = new Capnproto_test.Capnp.Test.TestAllTypes() + {}, EnumField = Capnproto_test.Capnp.Test.TestEnum.foo, VoidList = 0, BoolList = new bool[]{}, Int8List = new sbyte[]{}, Int16List = new short[]{}, Int32List = new int[]{}, Int64List = new long[]{}, UInt8List = new byte[]{}, UInt16List = new ushort[]{}, UInt32List = new uint[]{}, UInt64List = new ulong[]{}, Float32List = new float[]{}, Float64List = new double[]{}, TextList = new string[]{}, DataList = new IReadOnlyList[]{}, StructList = new Capnproto_test.Capnp.Test.TestAllTypes[]{}, EnumList = new Capnproto_test.Capnp.Test.TestEnum[]{}, InterfaceList = 0}, Bar = new uint[]{}}, InnerUnbound = new Capnproto_test.Capnp.Test.TestGenerics>.Inner() + {}}, RevFoo = new uint[]{12U, 34U, 56U}}; + } + + public Capnproto_test.Capnp.Test.TestGenerics Basic + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner Inner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 Inner2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Unspecified + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 UnspecifiedInner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Default + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner DefaultInner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestUseGenerics DefaultUser + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper Wrapper + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper DefaultWrapper + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper2 DefaultWrapper2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestAllTypes AliasFoo + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner AliasInner + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 AliasInner2 + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2> AliasInner2Bind + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2 AliasInner2Text + { + get; + set; + } + + public string AliasRev + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics>.UseAliases UseAliases + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics Cap + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestGenerics>.IInterface> GenericCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestGenerics.READER Basic => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER Inner => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER Inner2 => ctx.ReadStruct(2, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.READER Unspecified => ctx.ReadStruct(3, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER UnspecifiedInner => ctx.ReadStruct(4, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.READER Default => ctx.ReadStruct(5, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER DefaultInner => ctx.ReadStruct(6, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestUseGenerics.READER DefaultUser => ctx.ReadStruct(7, Capnproto_test.Capnp.Test.TestUseGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenericsWrapper.READER Wrapper => ctx.ReadStruct(8, Capnproto_test.Capnp.Test.TestGenericsWrapper.READER.create); + public Capnproto_test.Capnp.Test.TestGenericsWrapper.READER DefaultWrapper => ctx.ReadStruct(9, Capnproto_test.Capnp.Test.TestGenericsWrapper.READER.create); + public Capnproto_test.Capnp.Test.TestGenericsWrapper2.READER DefaultWrapper2 => ctx.ReadStruct(10, Capnproto_test.Capnp.Test.TestGenericsWrapper2.READER.create); + public Capnproto_test.Capnp.Test.TestAllTypes.READER AliasFoo => ctx.ReadStruct(11, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner.READER AliasInner => ctx.ReadStruct(12, Capnproto_test.Capnp.Test.TestGenerics.Inner.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER AliasInner2 => ctx.ReadStruct(13, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2>.READER AliasInner2Bind => ctx.ReadStruct(14, Capnproto_test.Capnp.Test.TestGenerics.Inner2>.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER AliasInner2Text => ctx.ReadStruct(15, Capnproto_test.Capnp.Test.TestGenerics.Inner2.READER.create); + public string AliasRev => ctx.ReadText(16, "text"); + public Capnproto_test.Capnp.Test.TestGenerics>.UseAliases.READER UseAliases => ctx.ReadStruct(17, Capnproto_test.Capnp.Test.TestGenerics>.UseAliases.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics.READER Cap => ctx.ReadStruct(18, Capnproto_test.Capnp.Test.TestGenerics.READER.create); + public Capnproto_test.Capnp.Test.TestGenerics>.IInterface> GenericCap => ctx.ReadCap>.IInterface>>(19); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 20); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Basic + { + get => BuildPointer.WRITER>(0); + set => Link(0, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER Inner + { + get => BuildPointer.Inner.WRITER>(1); + set => Link(1, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER Inner2 + { + get => BuildPointer.Inner2.WRITER>(2); + set => Link(2, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Unspecified + { + get => BuildPointer.WRITER>(3); + set => Link(3, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER UnspecifiedInner + { + get => BuildPointer.Inner2.WRITER>(4); + set => Link(4, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Default + { + get => BuildPointer.WRITER>(5); + set => Link(5, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER DefaultInner + { + get => BuildPointer.Inner.WRITER>(6); + set => Link(6, value); + } + + public Capnproto_test.Capnp.Test.TestUseGenerics.WRITER DefaultUser + { + get => BuildPointer(7); + set => Link(7, value); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper.WRITER Wrapper + { + get => BuildPointer.WRITER>(8); + set => Link(8, value); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper.WRITER DefaultWrapper + { + get => BuildPointer.WRITER>(9); + set => Link(9, value); + } + + public Capnproto_test.Capnp.Test.TestGenericsWrapper2.WRITER DefaultWrapper2 + { + get => BuildPointer(10); + set => Link(10, value); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER AliasFoo + { + get => BuildPointer(11); + set => Link(11, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner.WRITER AliasInner + { + get => BuildPointer.Inner.WRITER>(12); + set => Link(12, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER AliasInner2 + { + get => BuildPointer.Inner2.WRITER>(13); + set => Link(13, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2>.WRITER AliasInner2Bind + { + get => BuildPointer.Inner2>.WRITER>(14); + set => Link(14, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.Inner2.WRITER AliasInner2Text + { + get => BuildPointer.Inner2.WRITER>(15); + set => Link(15, value); + } + + public string AliasRev + { + get => this.ReadText(16, "text"); + set => this.WriteText(16, value, "text"); + } + + public Capnproto_test.Capnp.Test.TestGenerics>.UseAliases.WRITER UseAliases + { + get => BuildPointer>.UseAliases.WRITER>(17); + set => Link(17, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics.WRITER Cap + { + get => BuildPointer.WRITER>(18); + set => Link(18, value); + } + + public Capnproto_test.Capnp.Test.TestGenerics>.IInterface> GenericCap + { + get => ReadCap>.IInterface>>(19); + set => LinkObject(19, value); + } + } + } + + public class TestEmptyStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestConstants : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestAnyPointerConstants : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + AnyKindAsStruct = CapnpSerializable.Create(reader.AnyKindAsStruct); + AnyStructAsStruct = CapnpSerializable.Create(reader.AnyStructAsStruct); + AnyKindAsList = CapnpSerializable.Create(reader.AnyKindAsList); + AnyListAsList = reader.AnyListAsList.ToReadOnlyList(_ => (object)_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.AnyKindAsStruct.SetObject(AnyKindAsStruct); + writer.AnyStructAsStruct.SetObject(AnyStructAsStruct); + writer.AnyKindAsList.SetObject(AnyKindAsList); + writer.AnyListAsList.SetObject(AnyListAsList); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public AnyPointer AnyKindAsStruct + { + get; + set; + } + + public AnyPointer AnyStructAsStruct + { + get; + set; + } + + public AnyPointer AnyKindAsList + { + get; + set; + } + + public IReadOnlyList AnyListAsList + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState AnyKindAsStruct => ctx.StructReadPointer(0); + public DeserializerState AnyStructAsStruct => ctx.StructReadPointer(1); + public DeserializerState AnyKindAsList => ctx.StructReadPointer(2); + public IReadOnlyList AnyListAsList => (IReadOnlyList)ctx.ReadList(3); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 4); + } + + public DynamicSerializerState AnyKindAsStruct + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState AnyStructAsStruct + { + get => BuildPointer(1); + set => Link(1, value); + } + + public DynamicSerializerState AnyKindAsList + { + get => BuildPointer(2); + set => Link(2, value); + } + + public DynamicSerializerState AnyListAsList + { + get => BuildPointer(3); + set => Link(3, value); + } + } + } + + [Proxy(typeof(TestInterfaceProxy)), Skeleton(typeof(TestInterfaceSkeleton))] + public interface ITestInterface : IDisposable + { + Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default); + Task Bar(CancellationToken cancellationToken_ = default); + Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default); + } + + public class TestInterfaceProxy : Proxy, ITestInterface + { + public async Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_foo() + {I = i, J = j}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.X); + } + + public async Task Bar(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar() + {}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz() + {S = s}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestInterfaceSkeleton : Skeleton + { + public TestInterfaceSkeleton() + { + SetMethodTable(Foo, Bar, Baz); + } + + public override ulong InterfaceId => 9865999890858873522UL; + Task Foo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.J, cancellationToken_), x => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestInterface.Result_foo{X = x}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task Bar(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Bar(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Baz(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.Baz(in_.S, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static class TestInterface + { + public class Params_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + J = reader.J; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.J = J; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint I + { + get; + set; + } + + public bool J + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint I => ctx.ReadDataUInt(0UL, 0U); + public bool J => ctx.ReadDataBool(32UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint I + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public bool J + { + get => this.ReadDataBool(32UL, false); + set => this.WriteData(32UL, value, false); + } + } + } + + public class Result_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + X = reader.X; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.X = X; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string X + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string X => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string X + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_bar : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_bar : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_baz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = CapnpSerializable.Create(reader.S); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + S?.serialize(writer.S); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestAllTypes S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestAllTypes.READER S => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestAllTypes.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestAllTypes.WRITER S + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + + public class Result_baz : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestExtendsProxy)), Skeleton(typeof(TestExtendsSkeleton))] + public interface ITestExtends : Capnproto_test.Capnp.Test.ITestInterface + { + Task Qux(CancellationToken cancellationToken_ = default); + Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default); + Task Grault(CancellationToken cancellationToken_ = default); + } + + public class TestExtendsProxy : Proxy, ITestExtends + { + public async Task Qux(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_qux() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Grault(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_grault() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_foo() + {I = i, J = j}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.X); + } + + public async Task Bar(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar() + {}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz() + {S = s}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestExtendsSkeleton : Skeleton + { + public TestExtendsSkeleton() + { + SetMethodTable(Qux, Corge, Grault); + } + + public override ulong InterfaceId => 16494920484927878984UL; + async Task Qux(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Qux(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Corge(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Corge(CapnpSerializable.Create(d_), cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task Grault(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.Grault(cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestExtends + { + public class Params_qux : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_qux : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_corge : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_grault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestExtends2Proxy)), Skeleton(typeof(TestExtends2Skeleton))] + public interface ITestExtends2 : Capnproto_test.Capnp.Test.ITestExtends + { + } + + public class TestExtends2Proxy : Proxy, ITestExtends2 + { + public async Task Qux(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_qux() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Corge(Capnproto_test.Capnp.Test.TestAllTypes arg_, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Grault(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestExtends.Params_grault() + {}; + arg_.serialize(in_); + var d_ = await Call(16494920484927878984UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task Foo(uint i, bool j, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_foo() + {I = i, J = j}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.X); + } + + public async Task Bar(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_bar() + {}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Baz(Capnproto_test.Capnp.Test.TestAllTypes s, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestInterface.Params_baz() + {S = s}; + arg_.serialize(in_); + var d_ = await Call(9865999890858873522UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestExtends2Skeleton : Skeleton + { + public TestExtends2Skeleton() + { + SetMethodTable(); + } + + public override ulong InterfaceId => 11013518732491786115UL; + } + + [Proxy(typeof(TestPipelineProxy)), Skeleton(typeof(TestPipelineSkeleton))] + public interface ITestPipeline : IDisposable + { + Task<(string, Capnproto_test.Capnp.Test.TestPipeline.Box)> GetCap(uint n, Capnproto_test.Capnp.Test.ITestInterface inCap, CancellationToken cancellationToken_ = default); + Task TestPointers(Capnproto_test.Capnp.Test.ITestInterface cap, AnyPointer obj, IReadOnlyList list, CancellationToken cancellationToken_ = default); + Task<(string, Capnproto_test.Capnp.Test.TestPipeline.AnyBox)> GetAnyCap(uint n, BareProxy inCap, CancellationToken cancellationToken_ = default); + } + + public class TestPipelineProxy : Proxy, ITestPipeline + { + public Task<(string, Capnproto_test.Capnp.Test.TestPipeline.Box)> GetCap(uint n, Capnproto_test.Capnp.Test.ITestInterface inCap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestPipeline.Params_getCap() + {N = n, InCap = inCap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(11935670180855499984UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.S, r_.OutBox); + } + + ); + } + + public async Task TestPointers(Capnproto_test.Capnp.Test.ITestInterface cap, AnyPointer obj, IReadOnlyList list, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestPipeline.Params_testPointers() + {Cap = cap, Obj = obj, List = list}; + arg_.serialize(in_); + var d_ = await Call(11935670180855499984UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public Task<(string, Capnproto_test.Capnp.Test.TestPipeline.AnyBox)> GetAnyCap(uint n, BareProxy inCap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestPipeline.Params_getAnyCap() + {N = n, InCap = inCap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(11935670180855499984UL, 2, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.S, r_.OutBox); + } + + ); + } + } + + public class TestPipelineSkeleton : Skeleton + { + public TestPipelineSkeleton() + { + SetMethodTable(GetCap, TestPointers, GetAnyCap); + } + + public override ulong InterfaceId => 11935670180855499984UL; + Task GetCap(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.GetCap(in_.N, in_.InCap, cancellationToken_), (s, outBox) => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestPipeline.Result_getCap{S = s, OutBox = outBox}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task TestPointers(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.TestPointers(in_.Cap, in_.Obj, in_.List, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task GetAnyCap(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.GetAnyCap(in_.N, in_.InCap, cancellationToken_), (s, outBox) => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestPipeline.Result_getAnyCap{S = s, OutBox = outBox}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_getCap_OutBox_Cap = new MemberAccessPath(1U, 0U); + public static Capnproto_test.Capnp.Test.ITestInterface OutBox_Cap(this Task<(string, Capnproto_test.Capnp.Test.TestPipeline.Box)> task) + { + return (Capnproto_test.Capnp.Test.ITestInterface)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getCap_OutBox_Cap)); + } + + static readonly MemberAccessPath Path_getAnyCap_OutBox_Cap = new MemberAccessPath(1U, 0U); + public static BareProxy OutBox_Cap(this Task<(string, Capnproto_test.Capnp.Test.TestPipeline.AnyBox)> task) + { + return (BareProxy)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getAnyCap_OutBox_Cap)); + } + } + + public static class TestPipeline + { + public class Box : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class AnyBox : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public BareProxy Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public BareProxy Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public BareProxy Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_getCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + N = reader.N; + InCap = reader.InCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.N = N; + writer.InCap = InCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint N + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestInterface InCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint N => ctx.ReadDataUInt(0UL, 0U); + public Capnproto_test.Capnp.Test.ITestInterface InCap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint N + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public Capnproto_test.Capnp.Test.ITestInterface InCap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_getCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + OutBox = CapnpSerializable.Create(reader.OutBox); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + OutBox?.serialize(writer.OutBox); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestPipeline.Box OutBox + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestPipeline.Box.READER OutBox => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestPipeline.Box.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestPipeline.Box.WRITER OutBox + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class Params_testPointers : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + Obj = CapnpSerializable.Create(reader.Obj); + List = reader.List; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + writer.Obj.SetObject(Obj); + writer.List.Init(List); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public AnyPointer Obj + { + get; + set; + } + + public IReadOnlyList List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + public DeserializerState Obj => ctx.StructReadPointer(1); + public IReadOnlyList List => ctx.ReadCapList(2); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 3); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public DynamicSerializerState Obj + { + get => BuildPointer(1); + set => Link(1, value); + } + + public ListOfCapsSerializer List + { + get => BuildPointer>(2); + set => Link(2, value); + } + } + } + + public class Result_testPointers : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_getAnyCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + N = reader.N; + InCap = reader.InCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.N = N; + writer.InCap = InCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint N + { + get; + set; + } + + public BareProxy InCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint N => ctx.ReadDataUInt(0UL, 0U); + public BareProxy InCap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public uint N + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public BareProxy InCap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_getAnyCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + OutBox = CapnpSerializable.Create(reader.OutBox); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + OutBox?.serialize(writer.OutBox); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestPipeline.AnyBox OutBox + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.TestPipeline.AnyBox.READER OutBox => ctx.ReadStruct(1, Capnproto_test.Capnp.Test.TestPipeline.AnyBox.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.TestPipeline.AnyBox.WRITER OutBox + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + } + + [Proxy(typeof(TestCallOrderProxy)), Skeleton(typeof(TestCallOrderSkeleton))] + public interface ITestCallOrder : IDisposable + { + Task GetCallSequence(uint expected, CancellationToken cancellationToken_ = default); + } + + public class TestCallOrderProxy : Proxy, ITestCallOrder + { + public async Task GetCallSequence(uint expected, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence() + {Expected = expected}; + arg_.serialize(in_); + var d_ = await Call(11594359141811814481UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.N); + } + } + + public class TestCallOrderSkeleton : Skeleton + { + public TestCallOrderSkeleton() + { + SetMethodTable(GetCallSequence); + } + + public override ulong InterfaceId => 11594359141811814481UL; + Task GetCallSequence(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.GetCallSequence(in_.Expected, cancellationToken_), n => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestCallOrder.Result_getCallSequence{N = n}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestCallOrder + { + public class Params_getCallSequence : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Expected = reader.Expected; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Expected = Expected; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint Expected + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint Expected => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint Expected + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + + public class Result_getCallSequence : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + N = reader.N; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.N = N; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint N + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint N => ctx.ReadDataUInt(0UL, 0U); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public uint N + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + } + } + } + + [Proxy(typeof(TestTailCalleeProxy)), Skeleton(typeof(TestTailCalleeSkeleton))] + public interface ITestTailCallee : IDisposable + { + Task Foo(int i, string t, CancellationToken cancellationToken_ = default); + } + + public class TestTailCalleeProxy : Proxy, ITestTailCallee + { + public Task Foo(int i, string t, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestTailCallee.Params_foo() + {I = i, T = t}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15985132292242203195UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + ); + } + } + + public class TestTailCalleeSkeleton : Skeleton + { + public TestTailCalleeSkeleton() + { + SetMethodTable(Foo); + } + + public override ulong InterfaceId => 15985132292242203195UL; + Task Foo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.T, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_foo_C = new MemberAccessPath(1U); + public static Capnproto_test.Capnp.Test.ITestCallOrder C(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestCallOrder)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_foo_C)); + } + } + + public static class TestTailCallee + { + public class TailResult : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + T = reader.T; + C = reader.C; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.T = T; + writer.C = C; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public uint I + { + get; + set; + } + + public string T + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestCallOrder C + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public uint I => ctx.ReadDataUInt(0UL, 0U); + public string T => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.ITestCallOrder C => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public uint I + { + get => this.ReadDataUInt(0UL, 0U); + set => this.WriteData(0UL, value, 0U); + } + + public string T + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.ITestCallOrder C + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + } + + public class Params_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + T = reader.T; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.T = T; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int I + { + get; + set; + } + + public string T + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int I => ctx.ReadDataInt(0UL, 0); + public string T => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public int I + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public string T + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + } + + [Proxy(typeof(TestTailCallerProxy)), Skeleton(typeof(TestTailCallerSkeleton))] + public interface ITestTailCaller : IDisposable + { + Task Foo(int i, Capnproto_test.Capnp.Test.ITestTailCallee callee, CancellationToken cancellationToken_ = default); + } + + public class TestTailCallerProxy : Proxy, ITestTailCaller + { + public Task Foo(int i, Capnproto_test.Capnp.Test.ITestTailCallee callee, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestTailCaller.Params_foo() + {I = i, Callee = callee}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(9731139705278181429UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + ); + } + } + + public class TestTailCallerSkeleton : Skeleton + { + public TestTailCallerSkeleton() + { + SetMethodTable(Foo); + } + + public override ulong InterfaceId => 9731139705278181429UL; + Task Foo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Foo(in_.I, in_.Callee, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static partial class PipeliningSupportExtensions + { + } + + public static class TestTailCaller + { + public class Params_foo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + I = reader.I; + Callee = reader.Callee; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.I = I; + writer.Callee = Callee; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public int I + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestTailCallee Callee + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public int I => ctx.ReadDataInt(0UL, 0); + public Capnproto_test.Capnp.Test.ITestTailCallee Callee => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public int I + { + get => this.ReadDataInt(0UL, 0); + set => this.WriteData(0UL, value, 0); + } + + public Capnproto_test.Capnp.Test.ITestTailCallee Callee + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + } + + [Proxy(typeof(TestHandleProxy)), Skeleton(typeof(TestHandleSkeleton))] + public interface ITestHandle : IDisposable + { + } + + public class TestHandleProxy : Proxy, ITestHandle + { + } + + public class TestHandleSkeleton : Skeleton + { + public TestHandleSkeleton() + { + SetMethodTable(); + } + + public override ulong InterfaceId => 11785461720995412501UL; + } + + [Proxy(typeof(TestMoreStuffProxy)), Skeleton(typeof(TestMoreStuffSkeleton))] + public interface ITestMoreStuff : Capnproto_test.Capnp.Test.ITestCallOrder + { + Task CallFoo(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task CallFooWhenResolved(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task NeverReturn(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task Hold(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task CallHeld(CancellationToken cancellationToken_ = default); + Task GetHeld(CancellationToken cancellationToken_ = default); + Task Echo(Capnproto_test.Capnp.Test.ITestCallOrder cap, CancellationToken cancellationToken_ = default); + Task ExpectCancel(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default); + Task<(string, string)> MethodWithDefaults(string a, uint b, string c, CancellationToken cancellationToken_ = default); + Task GetHandle(CancellationToken cancellationToken_ = default); + Task GetNull(CancellationToken cancellationToken_ = default); + Task GetEnormousString(CancellationToken cancellationToken_ = default); + Task MethodWithNullDefault(string a, Capnproto_test.Capnp.Test.ITestInterface b, CancellationToken cancellationToken_ = default); + } + + public class TestMoreStuffProxy : Proxy, ITestMoreStuff + { + public async Task CallFoo(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFoo() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.S); + } + + public async Task CallFooWhenResolved(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callFooWhenResolved() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.S); + } + + public Task NeverReturn(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_neverReturn() + {Cap = cap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 2, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.CapCopy); + } + + ); + } + + public async Task Hold(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_hold() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 3, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task CallHeld(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_callHeld() + {}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 4, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.S); + } + + public Task GetHeld(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHeld() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 5, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Cap); + } + + ); + } + + public Task Echo(Capnproto_test.Capnp.Test.ITestCallOrder cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_echo() + {Cap = cap}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 6, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Cap); + } + + ); + } + + public async Task ExpectCancel(Capnproto_test.Capnp.Test.ITestInterface cap, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_expectCancel() + {Cap = cap}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 7, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task<(string, string)> MethodWithDefaults(string a, uint b, string c, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithDefaults() + {A = a, B = b, C = c}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 8, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.D, r_.E); + } + + public Task GetHandle(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getHandle() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 9, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Handle); + } + + ); + } + + public Task GetNull(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getNull() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(15980754968839795663UL, 10, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.NullCap); + } + + ); + } + + public async Task GetEnormousString(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_getEnormousString() + {}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 11, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.Str); + } + + public async Task MethodWithNullDefault(string a, Capnproto_test.Capnp.Test.ITestInterface b, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Params_methodWithNullDefault() + {A = a, B = b}; + arg_.serialize(in_); + var d_ = await Call(15980754968839795663UL, 12, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task GetCallSequence(uint expected, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestCallOrder.Params_getCallSequence() + {Expected = expected}; + arg_.serialize(in_); + var d_ = await Call(11594359141811814481UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return (r_.N); + } + } + + public class TestMoreStuffSkeleton : Skeleton + { + public TestMoreStuffSkeleton() + { + SetMethodTable(CallFoo, CallFooWhenResolved, NeverReturn, Hold, CallHeld, GetHeld, Echo, ExpectCancel, MethodWithDefaults, GetHandle, GetNull, GetEnormousString, MethodWithNullDefault); + } + + public override ulong InterfaceId => 15980754968839795663UL; + Task CallFoo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallFoo(in_.Cap, cancellationToken_), s => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFoo{S = s}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task CallFooWhenResolved(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallFooWhenResolved(in_.Cap, cancellationToken_), s => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callFooWhenResolved{S = s}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task NeverReturn(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.NeverReturn(in_.Cap, cancellationToken_), capCopy => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_neverReturn{CapCopy = capCopy}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task Hold(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.Hold(in_.Cap, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task CallHeld(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.CallHeld(cancellationToken_), s => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_callHeld{S = s}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetHeld(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetHeld(cancellationToken_), cap => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHeld{Cap = cap}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task Echo(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Echo(in_.Cap, cancellationToken_), cap => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_echo{Cap = cap}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task ExpectCancel(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.ExpectCancel(in_.Cap, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + Task MethodWithDefaults(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.MethodWithDefaults(in_.A, in_.B, in_.C, cancellationToken_), (d, e) => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_methodWithDefaults{D = d, E = e}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetHandle(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetHandle(cancellationToken_), handle => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getHandle{Handle = handle}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetNull(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetNull(cancellationToken_), nullCap => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getNull{NullCap = nullCap}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task GetEnormousString(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetEnormousString(cancellationToken_), str => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMoreStuff.Result_getEnormousString{Str = str}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task MethodWithNullDefault(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.MethodWithNullDefault(in_.A, in_.B, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_neverReturn_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestInterface Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestInterface)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_neverReturn_Eager)); + } + + static readonly MemberAccessPath Path_echo_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestCallOrder Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestCallOrder)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_echo_Eager)); + } + + static readonly MemberAccessPath Path_getHandle_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestHandle Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestHandle)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getHandle_Eager)); + } + + static readonly MemberAccessPath Path_getNull_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.ITestMoreStuff Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.ITestMoreStuff)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_getNull_Eager)); + } + } + + public static class TestMoreStuff + { + public class Params_callFoo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_callFoo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_callFooWhenResolved : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_callFooWhenResolved : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_neverReturn : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_neverReturn : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + CapCopy = reader.CapCopy; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.CapCopy = CapCopy; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface CapCopy + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface CapCopy => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface CapCopy + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_hold : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_hold : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_callHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_callHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + S = reader.S; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.S = S; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string S + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string S => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string S + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_getHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getHeld : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_echo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestCallOrder Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_echo : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestCallOrder Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestCallOrder Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_expectCancel : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_expectCancel : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_methodWithDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + A = reader.A; + B = reader.B; + C = reader.C; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.A = A; + writer.B = B; + writer.C = C; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + C = C ?? "foo"; + } + + public string A + { + get; + set; + } + + public uint B + { + get; + set; + } + + = 123U; + public string C + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string A => ctx.ReadText(0, ""); + public uint B => ctx.ReadDataUInt(0UL, 123U); + public string C => ctx.ReadText(1, "foo"); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 2); + } + + public string A + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public uint B + { + get => this.ReadDataUInt(0UL, 123U); + set => this.WriteData(0UL, value, 123U); + } + + public string C + { + get => this.ReadText(1, "foo"); + set => this.WriteText(1, value, "foo"); + } + } + } + + public class Result_methodWithDefaults : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + D = reader.D; + E = reader.E; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.D = D; + writer.E = E; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + E = E ?? "bar"; + } + + public string D + { + get; + set; + } + + public string E + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string D => ctx.ReadText(0, ""); + public string E => ctx.ReadText(1, "bar"); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string D + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public string E + { + get => this.ReadText(1, "bar"); + set => this.WriteText(1, value, "bar"); + } + } + } + + public class Params_getHandle : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getHandle : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Handle = reader.Handle; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Handle = Handle; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestHandle Handle + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestHandle Handle => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestHandle Handle + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_getNull : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getNull : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + NullCap = reader.NullCap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.NullCap = NullCap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.ITestMoreStuff NullCap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.ITestMoreStuff NullCap => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.ITestMoreStuff NullCap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_getEnormousString : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getEnormousString : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Str = reader.Str; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Str = Str; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Str + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Str => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Str + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_methodWithNullDefault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + A = reader.A; + B = reader.B; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.A = A; + writer.B = B; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string A + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestInterface B + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string A => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.ITestInterface B => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string A + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.ITestInterface B + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + } + + public class Result_methodWithNullDefault : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestMembraneProxy)), Skeleton(typeof(TestMembraneSkeleton))] + public interface ITestMembrane : IDisposable + { + Task MakeThing(CancellationToken cancellationToken_ = default); + Task CallPassThrough(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default); + Task CallIntercept(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default); + Task Loopback(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, CancellationToken cancellationToken_ = default); + Task WaitForever(CancellationToken cancellationToken_ = default); + } + + public class TestMembraneProxy : Proxy, ITestMembrane + { + public Task MakeThing(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_makeThing() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(13870398341137210380UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Thing); + } + + ); + } + + public async Task CallPassThrough(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_callPassThrough() + {Thing = thing, TailCall = tailCall}; + arg_.serialize(in_); + var d_ = await Call(13870398341137210380UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task CallIntercept(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, bool tailCall, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_callIntercept() + {Thing = thing, TailCall = tailCall}; + arg_.serialize(in_); + var d_ = await Call(13870398341137210380UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public Task Loopback(Capnproto_test.Capnp.Test.TestMembrane.IThing thing, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_loopback() + {Thing = thing}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(13870398341137210380UL, 3, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create(d_); + return (r_.Thing); + } + + ); + } + + public async Task WaitForever(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Params_waitForever() + {}; + arg_.serialize(in_); + var d_ = await Call(13870398341137210380UL, 4, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestMembraneSkeleton : Skeleton + { + public TestMembraneSkeleton() + { + SetMethodTable(MakeThing, CallPassThrough, CallIntercept, Loopback, WaitForever); + } + + public override ulong InterfaceId => 13870398341137210380UL; + Task MakeThing(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.MakeThing(cancellationToken_), thing => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMembrane.Result_makeThing{Thing = thing}; + r_.serialize(s_); + return s_; + } + + ); + } + + Task CallPassThrough(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallPassThrough(in_.Thing, in_.TailCall, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + + Task CallIntercept(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.CallIntercept(in_.Thing, in_.TailCall, cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + + Task Loopback(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + return Impatient.MaybeTailCall(Impl.Loopback(in_.Thing, cancellationToken_), thing => + { + var s_ = SerializerState.CreateForRpc(); + var r_ = new Capnproto_test.Capnp.Test.TestMembrane.Result_loopback{Thing = thing}; + r_.serialize(s_); + return s_; + } + + ); + } + + async Task WaitForever(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.WaitForever(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static partial class PipeliningSupportExtensions + { + static readonly MemberAccessPath Path_makeThing_Eager = new MemberAccessPath(0U); + public static Capnproto_test.Capnp.Test.TestMembrane.IThing Eager(this Task task) + { + return (Capnproto_test.Capnp.Test.TestMembrane.IThing)CapabilityReflection.CreateProxy(Impatient.GetAnswer(task).Access(Path_makeThing_Eager)); + } + } + + public static class TestMembrane + { + [Proxy(typeof(ThingProxy)), Skeleton(typeof(ThingSkeleton))] + public interface IThing : IDisposable + { + Task PassThrough(CancellationToken cancellationToken_ = default); + Task Intercept(CancellationToken cancellationToken_ = default); + } + + public class ThingProxy : Proxy, IThing + { + public async Task PassThrough(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_passThrough() + {}; + arg_.serialize(in_); + var d_ = await Call(10615798940090972439UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + + public async Task Intercept(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestMembrane.Thing.Params_intercept() + {}; + arg_.serialize(in_); + var d_ = await Call(10615798940090972439UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return r_; + } + } + + public class ThingSkeleton : Skeleton + { + public ThingSkeleton() + { + SetMethodTable(PassThrough, Intercept); + } + + public override ulong InterfaceId => 10615798940090972439UL; + Task PassThrough(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.PassThrough(cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + + Task Intercept(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.Intercept(cancellationToken_), r_ => + { + var s_ = SerializerState.CreateForRpc(); + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class Thing + { + public class Params_passThrough : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_intercept : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + public class Result : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Text = reader.Text; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Text = Text; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Text + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Text => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Text + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class Params_makeThing : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_makeThing : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_callPassThrough : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + TailCall = reader.TailCall; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + writer.TailCall = TailCall; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public bool TailCall + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + public bool TailCall => ctx.ReadDataBool(0UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public bool TailCall + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + } + } + + public class Params_callIntercept : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + TailCall = reader.TailCall; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + writer.TailCall = TailCall; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public bool TailCall + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + public bool TailCall => ctx.ReadDataBool(0UL, false); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public bool TailCall + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + } + } + + public class Params_loopback : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Result_loopback : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Thing = reader.Thing; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Thing = Thing; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing => ctx.ReadCap(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Thing + { + get => ReadCap(0); + set => LinkObject(0, value); + } + } + } + + public class Params_waitForever : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_waitForever : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + public class TestContainMembrane : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Cap = reader.Cap; + List = reader.List; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Cap = Cap; + writer.List.Init(List); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap + { + get; + set; + } + + public IReadOnlyList List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap => ctx.ReadCap(0); + public IReadOnlyList List => ctx.ReadCapList(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public Capnproto_test.Capnp.Test.TestMembrane.IThing Cap + { + get => ReadCap(0); + set => LinkObject(0, value); + } + + public ListOfCapsSerializer List + { + get => BuildPointer>(1); + set => Link(1, value); + } + } + } + + public class TestTransferCap : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + List = reader.List.ToReadOnlyList(_ => CapnpSerializable.Create(_)); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.List.Init(List, (_s1, _v1) => _v1?.serialize(_s1)); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public IReadOnlyList List + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public IReadOnlyList List => ctx.ReadList(0).Cast(Capnproto_test.Capnp.Test.TestTransferCap.Element.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public ListOfStructsSerializer List + { + get => BuildPointer>(0); + set => Link(0, value); + } + } + + public class Element : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Text = reader.Text; + Cap = reader.Cap; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Text = Text; + writer.Cap = Cap; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Text + { + get; + set; + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Text => ctx.ReadText(0, ""); + public Capnproto_test.Capnp.Test.ITestInterface Cap => ctx.ReadCap(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public string Text + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + + public Capnproto_test.Capnp.Test.ITestInterface Cap + { + get => ReadCap(1); + set => LinkObject(1, value); + } + } + } + } + + [Proxy(typeof(TestKeywordMethodsProxy)), Skeleton(typeof(TestKeywordMethodsSkeleton))] + public interface ITestKeywordMethods : IDisposable + { + Task Delete(CancellationToken cancellationToken_ = default); + Task Class(CancellationToken cancellationToken_ = default); + Task Void(CancellationToken cancellationToken_ = default); + Task Return(CancellationToken cancellationToken_ = default); + } + + public class TestKeywordMethodsProxy : Proxy, ITestKeywordMethods + { + public async Task Delete(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_delete() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Class(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_class() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 1, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Void(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_void() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 2, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + + public async Task Return(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestKeywordMethods.Params_return() + {}; + arg_.serialize(in_); + var d_ = await Call(11160837778045172988UL, 3, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestKeywordMethodsSkeleton : Skeleton + { + public TestKeywordMethodsSkeleton() + { + SetMethodTable(Delete, Class, Void, Return); + } + + public override ulong InterfaceId => 11160837778045172988UL; + async Task Delete(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Delete(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Class(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Class(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Void(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Void(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + + async Task Return(DeserializerState d_, CancellationToken cancellationToken_) + { + await Impl.Return(cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static class TestKeywordMethods + { + public class Params_delete : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_delete : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_class : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_class : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_void : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_void : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Params_return : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_return : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } + + [Proxy(typeof(TestAuthenticatedBootstrapProxy<>)), Skeleton(typeof(TestAuthenticatedBootstrapSkeleton<>))] + public interface ITestAuthenticatedBootstrap : IDisposable + { + Task GetCallerId(CancellationToken cancellationToken_ = default); + } + + public class TestAuthenticatedBootstrapProxy : Proxy, ITestAuthenticatedBootstrap where TVatId : class + { + public Task GetCallerId(CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc.Params_getCallerId.WRITER>(); + var arg_ = new Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap.Params_getCallerId() + {}; + arg_.serialize(in_); + return Impatient.MakePipelineAware(Call(16893789964317726925UL, 0, in_.Rewrap(), false, cancellationToken_), d_ => + { + var r_ = CapnpSerializable.Create.Result_getCallerId>(d_); + return (r_.Caller); + } + + ); + } + } + + public class TestAuthenticatedBootstrapSkeleton : Skeleton> where TVatId : class + { + public TestAuthenticatedBootstrapSkeleton() + { + SetMethodTable(GetCallerId); + } + + public override ulong InterfaceId => 16893789964317726925UL; + Task GetCallerId(DeserializerState d_, CancellationToken cancellationToken_) + { + return Impatient.MaybeTailCall(Impl.GetCallerId(cancellationToken_), caller => + { + var s_ = SerializerState.CreateForRpc.Result_getCallerId.WRITER>(); + var r_ = new Capnproto_test.Capnp.Test.TestAuthenticatedBootstrap.Result_getCallerId{Caller = caller}; + r_.serialize(s_); + return s_; + } + + ); + } + } + + public static class TestAuthenticatedBootstrap + where TVatId : class + { + public class Params_getCallerId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class Result_getCallerId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Caller = CapnpSerializable.Create(reader.Caller); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Caller.SetObject(Caller); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public TVatId Caller + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public DeserializerState Caller => ctx.StructReadPointer(0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public DynamicSerializerState Caller + { + get => BuildPointer(0); + set => Link(0, value); + } + } + } + } + + public class TestSturdyRef : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + HostId = CapnpSerializable.Create(reader.HostId); + ObjectId = CapnpSerializable.Create(reader.ObjectId); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + HostId?.serialize(writer.HostId); + writer.ObjectId.SetObject(ObjectId); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestSturdyRefHostId HostId + { + get; + set; + } + + public AnyPointer ObjectId + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestSturdyRefHostId.READER HostId => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestSturdyRefHostId.READER.create); + public DeserializerState ObjectId => ctx.StructReadPointer(1); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 2); + } + + public Capnproto_test.Capnp.Test.TestSturdyRefHostId.WRITER HostId + { + get => BuildPointer(0); + set => Link(0, value); + } + + public DynamicSerializerState ObjectId + { + get => BuildPointer(1); + set => Link(1, value); + } + } + } + + public class TestSturdyRefHostId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + Host = reader.Host; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.Host = Host; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public string Host + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public string Host => ctx.ReadText(0, ""); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 1); + } + + public string Host + { + get => this.ReadText(0, ""); + set => this.WriteText(0, value, ""); + } + } + } + + public class TestSturdyRefObjectId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + TheTag = reader.TheTag; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.TheTag = TheTag; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag TheTag + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag TheTag => (Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag)ctx.ReadDataUShort(0UL, (ushort)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag TheTag + { + get => (Capnproto_test.Capnp.Test.TestSturdyRefObjectId.Tag)this.ReadDataUShort(0UL, (ushort)0); + set => this.WriteData(0UL, (ushort)value, (ushort)0); + } + } + + public enum Tag : ushort + { + testInterface, + testExtends, + testPipeline, + testTailCallee, + testTailCaller, + testMoreStuff + } + } + + public class TestProvisionId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestRecipientId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestThirdPartyCapId : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestJoinResult : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + + public class TestNameAnnotation : ICapnpSerializable + { + public enum WHICH : ushort + { + BadFieldName = 0, + Bar = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.BadFieldName: + BadFieldName = reader.BadFieldName; + break; + case WHICH.Bar: + Bar = reader.Bar; + break; + } + + AnotherBadFieldName = reader.AnotherBadFieldName; + BadlyNamedUnion = CapnpSerializable.Create(reader.BadlyNamedUnion); + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.BadFieldName: + _content = false; + break; + case WHICH.Bar: + _content = 0; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.BadFieldName: + writer.BadFieldName = BadFieldName.Value; + break; + case WHICH.Bar: + writer.Bar = Bar.Value; + break; + } + + writer.AnotherBadFieldName = AnotherBadFieldName; + BadlyNamedUnion?.serialize(writer.BadlyNamedUnion); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool? BadFieldName + { + get => _which == WHICH.BadFieldName ? (bool? )_content : null; + set + { + _which = WHICH.BadFieldName; + _content = value; + } + } + + public sbyte? Bar + { + get => _which == WHICH.Bar ? (sbyte? )_content : null; + set + { + _which = WHICH.Bar; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum AnotherBadFieldName + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion BadlyNamedUnion + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(16U, (ushort)0); + public bool BadFieldName => which == WHICH.BadFieldName ? ctx.ReadDataBool(0UL, false) : default; + public sbyte Bar => which == WHICH.Bar ? ctx.ReadDataSByte(0UL, (sbyte)0) : default; + public Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum AnotherBadFieldName => (Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum)ctx.ReadDataUShort(32UL, (ushort)0); + public @badlyNamedUnion.READER BadlyNamedUnion => new @badlyNamedUnion.READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(16U, (ushort)0); + set => this.WriteData(16U, (ushort)value, (ushort)0); + } + + public bool BadFieldName + { + get => which == WHICH.BadFieldName ? this.ReadDataBool(0UL, false) : default; + set => this.WriteData(0UL, value, false); + } + + public sbyte Bar + { + get => which == WHICH.Bar ? this.ReadDataSByte(0UL, (sbyte)0) : default; + set => this.WriteData(0UL, value, (sbyte)0); + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum AnotherBadFieldName + { + get => (Capnproto_test.Capnp.Test.TestNameAnnotation.BadlyNamedEnum)this.ReadDataUShort(32UL, (ushort)0); + set => this.WriteData(32UL, (ushort)value, (ushort)0); + } + + public @badlyNamedUnion.WRITER BadlyNamedUnion + { + get => Rewrap<@badlyNamedUnion.WRITER>(); + } + } + + public class @badlyNamedUnion : ICapnpSerializable + { + public enum WHICH : ushort + { + BadlyNamedGroup = 0, + Baz = 1, + undefined = 65535 + } + + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + switch (reader.which) + { + case WHICH.BadlyNamedGroup: + BadlyNamedGroup = CapnpSerializable.Create(reader.BadlyNamedGroup); + break; + case WHICH.Baz: + Baz = CapnpSerializable.Create(reader.Baz); + break; + } + + applyDefaults(); + } + + private WHICH _which = WHICH.undefined; + private object _content; + public WHICH which + { + get => _which; + set + { + if (value == _which) + return; + _which = value; + switch (value) + { + case WHICH.BadlyNamedGroup: + _content = null; + break; + case WHICH.Baz: + _content = null; + break; + } + } + } + + public void serialize(WRITER writer) + { + writer.which = which; + switch (which) + { + case WHICH.BadlyNamedGroup: + BadlyNamedGroup?.serialize(writer.BadlyNamedGroup); + break; + case WHICH.Baz: + Baz?.serialize(writer.Baz); + break; + } + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion.@badlyNamedGroup BadlyNamedGroup + { + get => _which == WHICH.BadlyNamedGroup ? (Capnproto_test.Capnp.Test.TestNameAnnotation.@badlyNamedUnion.@badlyNamedGroup)_content : null; + set + { + _which = WHICH.BadlyNamedGroup; + _content = value; + } + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct Baz + { + get => _which == WHICH.Baz ? (Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct)_content : null; + set + { + _which = WHICH.Baz; + _content = value; + } + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public WHICH which => (WHICH)ctx.ReadDataUShort(48U, (ushort)0); + public @badlyNamedGroup.READER BadlyNamedGroup => which == WHICH.BadlyNamedGroup ? new @badlyNamedGroup.READER(ctx) : default; + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER Baz => which == WHICH.Baz ? ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER.create) : default; + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + + public WHICH which + { + get => (WHICH)this.ReadDataUShort(48U, (ushort)0); + set => this.WriteData(48U, (ushort)value, (ushort)0); + } + + public @badlyNamedGroup.WRITER BadlyNamedGroup + { + get => which == WHICH.BadlyNamedGroup ? Rewrap<@badlyNamedGroup.WRITER>() : default; + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.WRITER Baz + { + get => which == WHICH.Baz ? BuildPointer(0) : default; + set => Link(0, value); + } + } + + public class @badlyNamedGroup : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + } + } + } + } + + public enum BadlyNamedEnum : ushort + { + foo, + bar, + baz + } + + public class NestedStruct : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BadNestedFieldName = reader.BadNestedFieldName; + AnotherBadNestedFieldName = CapnpSerializable.Create(reader.AnotherBadNestedFieldName); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BadNestedFieldName = BadNestedFieldName; + AnotherBadNestedFieldName?.serialize(writer.AnotherBadNestedFieldName); + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public bool BadNestedFieldName + { + get; + set; + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct AnotherBadNestedFieldName + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public bool BadNestedFieldName => ctx.ReadDataBool(0UL, false); + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER AnotherBadNestedFieldName => ctx.ReadStruct(0, Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.READER.create); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 1); + } + + public bool BadNestedFieldName + { + get => this.ReadDataBool(0UL, false); + set => this.WriteData(0UL, value, false); + } + + public Capnproto_test.Capnp.Test.TestNameAnnotation.NestedStruct.WRITER AnotherBadNestedFieldName + { + get => BuildPointer(0); + set => Link(0, value); + } + } + + public enum DeeplyNestedEnum : ushort + { + quux, + corge, + grault + } + } + } + + [Proxy(typeof(TestNameAnnotationInterfaceProxy)), Skeleton(typeof(TestNameAnnotationInterfaceSkeleton))] + public interface ITestNameAnnotationInterface : IDisposable + { + Task BadlyNamedMethod(byte badlyNamedParam, CancellationToken cancellationToken_ = default); + } + + public class TestNameAnnotationInterfaceProxy : Proxy, ITestNameAnnotationInterface + { + public async Task BadlyNamedMethod(byte badlyNamedParam, CancellationToken cancellationToken_ = default) + { + var in_ = SerializerState.CreateForRpc(); + var arg_ = new Capnproto_test.Capnp.Test.TestNameAnnotationInterface.Params_badlyNamedMethod() + {BadlyNamedParam = badlyNamedParam}; + arg_.serialize(in_); + var d_ = await Call(15065286897585459595UL, 0, in_.Rewrap(), false, cancellationToken_).WhenReturned; + var r_ = CapnpSerializable.Create(d_); + return; + } + } + + public class TestNameAnnotationInterfaceSkeleton : Skeleton + { + public TestNameAnnotationInterfaceSkeleton() + { + SetMethodTable(BadlyNamedMethod); + } + + public override ulong InterfaceId => 15065286897585459595UL; + async Task BadlyNamedMethod(DeserializerState d_, CancellationToken cancellationToken_) + { + var in_ = CapnpSerializable.Create(d_); + await Impl.BadlyNamedMethod(in_.BadlyNamedParam, cancellationToken_); + var s_ = SerializerState.CreateForRpc(); + return s_; + } + } + + public static class TestNameAnnotationInterface + { + public class Params_badlyNamedMethod : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + BadlyNamedParam = reader.BadlyNamedParam; + applyDefaults(); + } + + public void serialize(WRITER writer) + { + writer.BadlyNamedParam = BadlyNamedParam; + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public byte BadlyNamedParam + { + get; + set; + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + public byte BadlyNamedParam => ctx.ReadDataByte(0UL, (byte)0); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(1, 0); + } + + public byte BadlyNamedParam + { + get => this.ReadDataByte(0UL, (byte)0); + set => this.WriteData(0UL, value, (byte)0); + } + } + } + + public class Result_badlyNamedMethod : ICapnpSerializable + { + void ICapnpSerializable.Deserialize(DeserializerState arg_) + { + var reader = READER.create(arg_); + applyDefaults(); + } + + public void serialize(WRITER writer) + { + } + + void ICapnpSerializable.Serialize(SerializerState arg_) + { + serialize(arg_.Rewrap()); + } + + public void applyDefaults() + { + } + + public struct READER + { + readonly DeserializerState ctx; + public READER(DeserializerState ctx) + { + this.ctx = ctx; + } + + public static READER create(DeserializerState ctx) => new READER(ctx); + public static implicit operator DeserializerState(READER reader) => reader.ctx; + public static implicit operator READER(DeserializerState ctx) => new READER(ctx); + } + + public class WRITER : SerializerState + { + public WRITER() + { + this.SetStruct(0, 0); + } + } + } + } +} \ No newline at end of file