/// <summary>
/// End a file
/// </summary>
protected override void WriteFileFooter(GeneratorContext ctx, FileDescriptorProto file, ref object state)
{
if (ctx.Supports(VB14))
{
ctx.WriteLine($"#Enable Warning BC40008, BC40055, IDE1006").WriteLine();
}
}
internal void AddFile(FileDescriptorProto fileDescriptor)
{
if (_filesByName.ContainsKey(fileDescriptor.Name))
{
return;
}
_filesByName.Add(fileDescriptor.Name, fileDescriptor);
foreach (var dependency in fileDescriptor.GetDependencies())
{
AddFile(dependency);
}
foreach (var enumeration in fileDescriptor.EnumTypes)
{
AddEnum(enumeration);
}
foreach (var message in fileDescriptor.MessageTypes)
{
AddMessage(message);
}
foreach (var service in fileDescriptor.Services)
{
AddService(service);
}
}
ProtoTypeNode GetOrCreateTypeNode(string name, FileDescriptorProto proto = null, object source = null)
{
if (!protobufTypeMap.TryGetValue(name, out var node))
{
node = new ProtoTypeNode()
{
Name = name,
Proto = proto,
Source = source,
Defined = source != null
};
protobufTypeMap.Add(name, node);
}
else if (source != null)
{
Debug.Assert(node.Defined == false);
node.Proto = proto;
node.Source = source;
node.Defined = true;
}
return(node);
}
/// <summary>
/// Create a new GeneratorContext instance
/// </summary>
internal GeneratorContext(FileDescriptorProto file, NameNormalizer nameNormalizer, TextWriter output, string indentToken)
{
File = file;
NameNormalizer = nameNormalizer;
Output = output;
IndentToken = indentToken;
}
Dictionary <string, string> DumpOptions(FileDescriptorProto source, MessageOptions options)
{
var optionsKv = new Dictionary <string, string>();
if (options == null)
{
return(optionsKv);
}
if (options.message_set_wire_formatSpecified)
{
optionsKv.Add("message_set_wire_format", options.message_set_wire_format ? "true" : "false");
}
if (options.no_standard_descriptor_accessorSpecified)
{
optionsKv.Add("no_standard_descriptor_accessor", options.no_standard_descriptor_accessor ? "true" : "false");
}
if (options.deprecatedSpecified)
{
optionsKv.Add("deprecated", options.deprecated ? "true" : "false");
}
DumpOptionsMatching(source, ".google.protobuf.MessageOptions", options, optionsKv);
return(optionsKv);
}
public void AddMessagesToReset(DescriptorProto proto_msg, FileDescriptorProto fileDescriptor)
{
var key = GetMessageCSharpName(proto_msg.Name, fileDescriptor.Package);
var fields_list = proto_msg.Fields;
foreach (var field in fields_list)
{
if (field.type == FieldDescriptorProto.Type.TypeMessage)//todo
{
//var key_nested = GetMessageCSharpName(origin_typename, ns);
//DescriptorProto depend_proto_msg;
//if(MessagesReceive.TryGetValue(key_nested, out depend_proto_msg))
//{
// continue;
//}
//else
//{
// Messages.TryGetValue(key_nested, out depend_proto_msg);
// Console.WriteLine("key_nested " + key_nested);
// AddMessagesToReset(depend_proto_msg, ns);
//}
}
}
MessagesReceive.Add(key, proto_msg);
}
private void DoParseFile(FileDescriptorProto set)
{
StringBuilder sb = new StringBuilder();
DumpFileDescriptor(set, sb);
FinalProtoDefinition.Add(new ProtoData {
file = set, buffer = sb
});
ProtoList.Add(set.name);
List <FileDescriptorProto> protosToRender = new List <FileDescriptorProto>();
do
{
protosToRender.Clear();
foreach (var proto in deferredProtos)
{
if (!ShouldDeferProto(proto))
{
protosToRender.Add(proto);
}
}
foreach (var proto in protosToRender)
{
deferredProtos.Remove(proto);
DoParseFile(proto);
}
}while (protosToRender.Count != 0);
}
/// <summary>
/// End a file
/// </summary>
protected override void WriteFileFooter(GeneratorContext ctx, FileDescriptorProto file, ref object state)
{
var @namespace = (string)state;
if (!string.IsNullOrWhiteSpace(@namespace))
{
ctx.Outdent().WriteLine("}").WriteLine();
}
var @filename = file.Name.Substring(0, file.Name.IndexOf("."));
ctx.WriteLine($"public class ILRuntime_{@filename}");
ctx.WriteLine("{").Indent();
ctx.WriteLine($"static ILRuntime_{@filename}()");
ctx.WriteLine("{");
ctx.WriteLine().Indent();
ctx.WriteLine($"//Initlize();");
ctx.WriteLine().Outdent();
ctx.WriteLine("}");
ctx.WriteLine($"public static void Initlize()");
ctx.WriteLine("{");
ctx.WriteLine().Indent();
foreach (var T in TypeNames2)
{
ctx.WriteLine($@"ProtoBuf.PType.RegisterType(""{T}"", typeof({T}));");
}
ctx.WriteLine().Outdent();
ctx.WriteLine("}").Outdent();
ctx.WriteLine("}").WriteLine();
ctx.WriteLine("#pragma warning restore CS1591, CS0612, CS3021");
}
private void CheckByEachFile(FileDescriptorProto protofile)
{
foreach (ServiceDescriptorProto service in protofile.Service)
{
CheckEachService(service);
}
}
/// <summary>
/// Start a file
/// </summary>
protected override void WriteFileHeader(GeneratorContext ctx, FileDescriptorProto file, ref object state)
{
var prefix = ctx.Supports(CSharp6) ? "CS" : "";
var tw = ctx.WriteLine("// <auto-generated>")
.WriteLine("// This file was generated by a tool; you should avoid making direct changes.")
.WriteLine("// Consider using 'partial classes' to extend these types")
.WriteLine($"// Input: {Path.GetFileName(ctx.File.Name)}")
.WriteLine("// </auto-generated>")
.WriteLine()
.WriteLine("#region Designer generated code")
.Write($"#pragma warning disable {prefix}0612, {prefix}1591, {prefix}3021");
if (ctx.Supports(CSharp6))
{
tw.Write(AdditionalSuppressionCodes);
}
tw.WriteLine();
var @namespace = ctx.NameNormalizer.GetName(file);
if (!string.IsNullOrWhiteSpace(@namespace))
{
state = @namespace;
ctx.WriteLine($"namespace {@namespace}");
ctx.WriteLine("{").Indent().WriteLine();
}
}
void DumpService(FileDescriptorProto source, ServiceDescriptorProto service, StringBuilder sb)
{
sb.AppendLine($"service {service.name} {{");
foreach (var option in DumpOptions(source, service.options))
{
sb.AppendLine($"\toption {option.Key} = {option.Value};");
}
foreach (var method in service.method)
{
var declaration = $"\trpc {method.name} ({method.input_type}) returns ({method.output_type})";
var options = DumpOptions(source, method.options);
if (options.Count == 0)
{
sb.AppendLine($"{declaration};");
}
else
{
sb.AppendLine($"{declaration} {{");
foreach (var option in options)
{
sb.AppendLine($"\t\toption {option.Key} = {option.Value};");
}
sb.AppendLine("\t}");
}
}
sb.AppendLine("}");
sb.AppendLine();
}
/// <summary>
/// Builds a FileDescriptor from its protocol buffer representation.
/// </summary>
/// <param name="descriptorData">The original serialized descriptor data.
/// We have only limited proto2 support, so serializing FileDescriptorProto
/// would not necessarily give us this.</param>
/// <param name="proto">The protocol message form of the FileDescriptor.</param>
/// <param name="dependencies">FileDescriptors corresponding to all of the
/// file's dependencies, in the exact order listed in the .proto file. May be null,
/// in which case it is treated as an empty array.</param>
/// <param name="allowUnknownDependencies">Whether unknown dependencies are ignored (true) or cause an exception to be thrown (false).</param>
/// <param name="generatedCodeInfo">Details about generated code, for the purposes of reflection.</param>
/// <exception cref="DescriptorValidationException">If <paramref name="proto"/> is not
/// a valid descriptor. This can occur for a number of reasons, such as a field
/// having an undefined type or because two messages were defined with the same name.</exception>
private static FileDescriptor BuildFrom(ByteString descriptorData, FileDescriptorProto proto, FileDescriptor[] dependencies, bool allowUnknownDependencies, GeneratedClrTypeInfo generatedCodeInfo)
{
// Building descriptors involves two steps: translating and linking.
// In the translation step (implemented by FileDescriptor's
// constructor), we build an object tree mirroring the
// FileDescriptorProto's tree and put all of the descriptors into the
// DescriptorPool's lookup tables. In the linking step, we look up all
// type references in the DescriptorPool, so that, for example, a
// FieldDescriptor for an embedded message contains a pointer directly
// to the Descriptor for that message's type. We also detect undefined
// types in the linking step.
if (dependencies == null)
{
dependencies = new FileDescriptor[0];
}
DescriptorPool pool = new DescriptorPool(dependencies);
FileDescriptor result = new FileDescriptor(descriptorData, proto, dependencies, pool, allowUnknownDependencies, generatedCodeInfo);
// Validate that the dependencies we've been passed (as FileDescriptors) are actually the ones we
// need.
if (dependencies.Length != proto.Dependency.Count)
{
throw new DescriptorValidationException(
result,
"Dependencies passed to FileDescriptor.BuildFrom() don't match " +
"those listed in the FileDescriptorProto.");
}
result.CrossLink();
return(result);
}
protected override void WriteFile(GeneratorContext ctx, FileDescriptorProto obj)
{
var file = ctx.File;
var ast = new ProtoFile
{
PackageName = file.Package,
CsNamespace = file.Options?.CsharpNamespace ?? file.Package,
Messages = file
.MessageTypes
.ToArray()
.Select(mt => new ProtoMessage {
Name = mt.Name
})
.ToArray(),
Services = file
.Services
.ToArray()
.Select(s => new ProtoService
{
Name = s.Name,
Methods = s.Methods.ToArray().Select(m => new ProtoMethod
{
Name = m.Name,
InputName = RemovePackageName(m.InputType),
OutputName = RemovePackageName(m.OutputType),
}).ToArray()
})
.ToArray()
};
var f = Handlebars.Compile(Template.Code);
var result = f(ast);
ctx.WriteLine(result);
}
public void ExampleImport()
{
using (var stream = File.OpenRead(@"protobuf/example.import"))
{
FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream);
Google.Protobuf.Collections.RepeatedField <FileDescriptorProto> descriptorsProto = descriptorSet.File;
FileDescriptorProto a = descriptorsProto[0];
FileDescriptorProto b = descriptorsProto[1];
FileDescriptorProto bb = descriptorsProto[2];
FileDescriptorProto c = descriptorsProto[3];
FileDescriptorProto cc = descriptorsProto[4];
Assert.That(b.Dependency.Count, Is.EqualTo(1));
Assert.That(b.Dependency[0], Contains.Substring("A.proto"));
Assert.That(b.PublicDependency.Count, Is.EqualTo(0));
Assert.That(bb.Dependency.Count, Is.EqualTo(1));
Assert.That(bb.Dependency[0], Contains.Substring("B.proto"));
Assert.That(bb.PublicDependency.Count, Is.EqualTo(0));
Assert.That(c.Dependency.Count, Is.EqualTo(1));
Assert.That(c.Dependency[0], Contains.Substring("A.proto"));
Assert.That(c.PublicDependency.Count, Is.EqualTo(1));
Assert.That(cc.Dependency.Count, Is.EqualTo(1));
Assert.That(cc.Dependency[0], Contains.Substring("C.proto"));
Assert.That(cc.PublicDependency.Count, Is.EqualTo(1));
}
}
public void Test1()
{
using (var stream = File.OpenRead(@"mymodel"))
{
FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream);
Google.Protobuf.Collections.RepeatedField <FileDescriptorProto> descriptorsProto = descriptorSet.File;
FileDescriptorProto info = descriptorsProto[0];
var service = info.Service[0];
Console.WriteLine("---------------");
Console.WriteLine("| <<Service>> |");
Console.WriteLine($"| {service.Name} |");
Console.WriteLine("---------------");
foreach (MethodDescriptorProto method in service.Method)
{
Console.WriteLine($"| + {method.OutputType} {method.Name}({method.InputType}) |");
}
Console.WriteLine("---------------");
foreach (DescriptorProto message in info.MessageType)
{
Console.WriteLine("---------------");
Console.WriteLine($"| {message.Name} |");
Console.WriteLine("---------------");
foreach (var field in message.Field)
{
Console.WriteLine($"| + {field.TypeName} {field.Name} |");
}
Console.WriteLine("---------------");
}
}
}
void DumpEnumDescriptor(FileDescriptorProto source, EnumDescriptorProto field, StringBuilder sb, int level, ref bool marker)
{
var levelspace = new string( '\t', level );
AppendHeadingSpace(sb, ref marker);
sb.AppendLine($"{levelspace}enum {field.name} {{");
foreach (var option in DumpOptions(source, field.options))
{
sb.AppendLine($"{levelspace}\toption {option.Key} = {option.Value};");
}
foreach (var enumValue in field.value)
{
var options = DumpOptions(source, enumValue.options);
var parameters = string.Empty;
if (options.Count > 0)
{
parameters = $" [{string.Join( ", ", options.Select( kvp => $"{kvp.Key} = {kvp.Value}" ) )}]";
}
sb.AppendLine($"{levelspace}\t{enumValue.name} = {enumValue.number}{parameters};");
}
sb.AppendLine($"{levelspace}}}");
marker = true;
}
/// <summary>
/// Emits the code for a file in a descriptor-set
/// </summary>
protected virtual void WriteFile(GeneratorContext ctx, FileDescriptorProto obj)
{
var file = ctx.File;
object state = null;
WriteFileHeader(ctx, obj, ref state);
foreach (var inner in file.MessageTypes)
{
WriteMessage(ctx, inner);
}
foreach (var inner in file.EnumTypes)
{
WriteEnum(ctx, inner);
}
foreach (var inner in file.Services)
{
WriteService(ctx, inner);
}
if (file.Extensions.Count != 0)
{
object extState = null;
WriteExtensionsHeader(ctx, file, ref extState);
foreach (var ext in file.Extensions)
{
WriteExtension(ctx, ext);
}
WriteExtensionsFooter(ctx, file, ref extState);
}
WriteFileFooter(ctx, obj, ref state);
}
void DumpFileDescriptor(FileDescriptorProto proto, StringBuilder sb)
{
if (!string.IsNullOrEmpty(proto.package))
{
PushDescriptorName(proto);
}
var marker = false;
for (var i = 0; i < proto.dependency.Count; i++)
{
var dependency = proto.dependency[i];
var modifier = proto.public_dependency.Contains(i) ? "public " : "";
sb.AppendLine($"import {modifier}\"{dependency}\";");
marker = true;
}
if (!string.IsNullOrEmpty(proto.package))
{
AppendHeadingSpace(sb, ref marker);
sb.AppendLine($"package {proto.package};");
marker = true;
}
var options = DumpOptions(proto, proto.options);
foreach (var option in options)
{
AppendHeadingSpace(sb, ref marker);
sb.AppendLine($"option {option.Key} = {option.Value};");
}
if (options.Count > 0)
{
marker = true;
}
DumpExtensionDescriptors(proto, proto.extension, sb, 0, ref marker);
foreach (var field in proto.enum_type)
{
DumpEnumDescriptor(proto, field, sb, 0, ref marker);
}
foreach (var message in proto.message_type)
{
DumpDescriptor(proto, message, sb, 0, ref marker);
}
foreach (var service in proto.service)
{
DumpService(proto, service, sb, ref marker);
}
if (!string.IsNullOrEmpty(proto.package))
{
PopDescriptorName();
}
}
private Dictionary <string, string> DumpOptions(FileDescriptorProto source, FileOptions options)
{
var optionsKv = new Dictionary <string, string>();
if (options == null)
{
return(optionsKv);
}
if (options.deprecatedSpecified)
{
optionsKv.Add("deprecated", options.deprecated ? "true" : "false");
}
if (options.optimize_forSpecified)
{
optionsKv.Add("optimize_for", $"{options.optimize_for}");
}
if (options.cc_generic_servicesSpecified)
{
optionsKv.Add("cc_generic_services", options.cc_generic_services ? "true" : "false");
}
if (options.go_packageSpecified)
{
optionsKv.Add("go_package", $"\"{options.go_package}\"");
}
if (options.java_packageSpecified)
{
optionsKv.Add("java_package", $"\"{options.java_package}\"");
}
if (options.java_outer_classnameSpecified)
{
optionsKv.Add("java_outer_classname", $"\"{options.java_outer_classname}\"");
}
if (options.java_generate_equals_and_hashSpecified)
{
optionsKv.Add("java_generate_equals_and_hash",
options.java_generate_equals_and_hash ? "true" : "false");
}
if (options.java_generic_servicesSpecified)
{
optionsKv.Add("java_generic_services", options.java_generic_services ? "true" : "false");
}
if (options.java_multiple_filesSpecified)
{
optionsKv.Add("java_multiple_files", options.java_multiple_files ? "true" : "false");
}
if (options.java_string_check_utf8Specified)
{
optionsKv.Add("java_string_check_utf8", options.java_string_check_utf8 ? "true" : "false");
}
if (options.py_generic_servicesSpecified)
{
optionsKv.Add("py_generic_services", options.py_generic_services ? "true" : "false");
}
DumpOptionsMatching(source, ".google.protobuf.FileOptions", options, optionsKv);
return(optionsKv);
}
protected override void GenerateByEachFile(FileDescriptorProto protofile, CodeGeneratorResponse response)
{
bool genericClient;
protofile.Options.CustomOptions.TryGetBool(DotBPEOptions.DISABLE_GENERIC_SERVICES_CLIENT, out genericClient);
if (genericClient)
{
return;
}
if (protofile.Service == null || protofile.Service.Count <= 0)
{
return;
}
//生成文件头
StringBuilder sb = new StringBuilder();
sb.AppendLine("// Generated by the protocol buffer compiler. DO NOT EDIT!");
sb.AppendLine($"// source: {protofile.Name}");
//还可以生成注释
sb.AppendLine("#region Designer generated code");
sb.AppendLine("");
sb.AppendLine("using System; ");
sb.AppendLine("using System.Threading.Tasks; ");
sb.AppendLine("using DotBPE.Rpc; ");
sb.AppendLine("using DotBPE.Protocol.Amp; ");
sb.AppendLine("using DotBPE.Rpc.Exceptions; ");
sb.AppendLine("using Google.Protobuf; ");
sb.AppendLine("");
string ns = Utils.GetFileNamespace(protofile);
sb.AppendLine("namespace " + ns + " {");
//生成代码
foreach (ServiceDescriptorProto t in protofile.Service)
{
t.Options.CustomOptions.TryGetBool(DotBPEOptions.DISABLE_GENERIC_SERVICES_CLIENT, out genericClient);
if (genericClient)
{
continue;
}
sb.AppendLine("");
sb.AppendLine("//start for class " + t.Name + "Client");
GenerateServiceForClient(t, sb);
sb.AppendLine("//end for class " + t.Name + "Client");
}
sb.AppendLine("}");
sb.AppendLine("#endregion");
//生成文件
var nfile = new CodeGeneratorResponse.Types.File
{
Name = Utils.GetFileName(protofile.Name) + "Client.cs",
Content = sb.ToString()
};
response.File.Add(nfile);
}
static byte[] SerializeFileDescriptor(FileDescriptorProto descriptor)
{
using (var stream = new MemoryStream(4096))
{
Serializer.Serialize(stream, descriptor);
return(stream.ToArray());
}
}
private string BuildDescriptorDeclaration(FileDescriptorProto source, FieldDescriptorProto field,
bool emitFieldLabel = true)
{
PushDescriptorName(field);
var type = ResolveType(field);
var options = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(field.default_value))
{
var defaultValue = field.default_value;
if (field.type == FieldDescriptorProto.Type.TYPE_STRING)
{
defaultValue = $"\"{defaultValue}\"";
}
options.Add("default", defaultValue);
}
else if (field.type == FieldDescriptorProto.Type.TYPE_ENUM &&
field.label != FieldDescriptorProto.Label.LABEL_REPEATED)
{
var lookup = _protobufTypeMap[field.type_name];
if (lookup.Source is EnumDescriptorProto enumDescriptor && enumDescriptor.value.Count > 0)
{
options.Add("default", enumDescriptor.value[0].name);
}
}
var fieldOptions = DumpOptions(source, field.options);
foreach (var(key, value) in fieldOptions)
{
options[key] = value;
}
var parameters = string.Empty;
if (options.Count > 0)
{
parameters = $" [{string.Join(", ", options.Select(kvp => $"{kvp.Key} = {kvp.Value}"))}]";
}
PopDescriptorName();
var descriptorDeclarationBuilder = new StringBuilder();
if (emitFieldLabel)
{
descriptorDeclarationBuilder.Append(GetLabel(field.label));
descriptorDeclarationBuilder.Append(" ");
}
descriptorDeclarationBuilder.Append($"{type} {field.name} = {field.number}{parameters};");
return(descriptorDeclarationBuilder.ToString());
}
private bool HandleProto(string name, byte[] data)
{
//if (name == "google/protobuf/descriptor.proto")
// return true;
Console.WriteLine("Found protobuf candidate '{0}'!", name);
FileDescriptorProto set = null;
if (Environment.GetCommandLineArgs().Contains("-dump", StringComparer.OrdinalIgnoreCase))
{
string fileName = Path.Combine(OutputDir, name + ".dump");
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
Console.WriteLine(" ! Dumping to '{0}'!", fileName);
try
{
File.WriteAllBytes(fileName, data);
}
catch (Exception ex)
{
Console.WriteLine("Unable to dump: {0}", ex.Message);
return(true);
}
}
try
{
using (MemoryStream ms = new MemoryStream(data))
set = Serializer.Deserialize <FileDescriptorProto>(ms);
}
catch (Exception ex)
{
if (ex.GetType() == typeof(EndOfStreamException))
{
Console.WriteLine("'{0}' needs rescan: {1}\n", name, ex.Message);
return(false);
}
Console.WriteLine("'{0}' was invalid: {1}\n", name, ex.Message);
return(true);
}
if (ShouldDeferProto(set))
{
Console.WriteLine(" ! Deferring parsing proto '{0}'\n", set.name);
deferredProtos.Add(set);
}
else
{
DoParseFile(set);
}
return(true);
}
public override Writer <T> AddWriter <T>(string topic)
{
var msgType = typeof(T).ToString();
string descriptorName = NameByMsgType[msgType];
FileDescriptorProto descriptor = DescriptorByName[descriptorName].Item2;
var descriptors = new List <byte[]>();
GetDescriptors(descriptors, descriptor);
int count = descriptors.Count;
var data = new List <byte>(4096);
data.Add((byte)Op.RegisterDesc);
data.Add((byte)(count >> 0));
data.Add((byte)(count >> 8));
data.Add((byte)(count >> 16));
data.Add((byte)(count >> 24));
foreach (var s in descriptors)
{
int bytes = s.Length;
data.Add((byte)(bytes >> 0));
data.Add((byte)(bytes >> 8));
data.Add((byte)(bytes >> 16));
data.Add((byte)(bytes >> 24));
data.AddRange(s);
}
var channel = System.Text.Encoding.ASCII.GetBytes(topic);
byte[] descriptorData = DescriptorByName[descriptorName].Item1;
var typeb = System.Text.Encoding.ASCII.GetBytes(msgType);
data.Add((byte)Op.AddWriter);
data.Add((byte)(channel.Length >> 0));
data.Add((byte)(channel.Length >> 8));
data.Add((byte)(channel.Length >> 16));
data.Add((byte)(channel.Length >> 24));
data.AddRange(channel);
data.Add((byte)(typeb.Length >> 0));
data.Add((byte)(typeb.Length >> 8));
data.Add((byte)(typeb.Length >> 16));
data.Add((byte)(typeb.Length >> 24));
data.AddRange(typeb);
TopicPublishers.Add(new Topic()
{
Name = topic,
Type = typeof(T).ToString(),
});
SendAsync(data.ToArray());
return(new CyberWriter <T>(this, topic));
}
static void WorkSingleEntry(Docs.ServiceDocFactory docs, FileDescriptorProto filedesc, ServiceDescriptorProto service, List <NameInfo> names, string sourceFile)
{
var targetName = filedesc.Options?.CsharpNamespace ?? "";
if (targetName.StartsWith(settings.NamespaceBase))
{
targetName = targetName.Substring(settings.NamespaceBase.Length);
}
else
{
log.WriteWarning(text: $"the c# namespace {targetName} has not the base {settings.NamespaceBase}. The namespace will not be shortened.",
file: filedesc.Name);
}
if (targetName != null)
{
targetName += '.';
}
targetName = (targetName + service.Name).Replace('.', '/');
if (targetName.StartsWith("/"))
{
targetName = targetName.Substring(1);
}
targetName = Path.Combine(settings.OutputDir + "/", targetName + settings.FileExtension);
if (settings.Verbose)
{
Console.WriteLine($" Generate service for {service.Name} at {targetName}...");
}
var fi = new FileInfo(targetName);
if (!fi.Directory.Exists)
{
try { fi.Directory.Create(); }
catch (IOException e)
{
log.WriteError(text: $"Couldn't create directory for output file {targetName}: {e}",
file: filedesc.Name);
return;
}
}
using var writer = new StreamWriter(new FileStream(targetName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite));
writer.BaseStream.SetLength(0);
Generator generator = settings.OutputFormat switch
{
"1" => new Generator(docs, settings, log),
"2" => new Generator2(docs, settings, log),
_ => new Generator(docs, settings, log),
};
generator.GenerateServiceFile(filedesc, service, writer, names);
writer.Flush();
if (report != null)
{
if (settings.BuildProtoc)
{
sourceFile = sourceFile[0..^ 4];
public static string GetFileNamespace(FileDescriptorProto protofile)
{
string ns = protofile.Options.CsharpNamespace;
if (string.IsNullOrEmpty(ns))
{
throw new Exception("" + protofile.Name + ".proto did not set csharp_namespace");
}
return(ConvertCamelCase(ns));
}
public void ToJsonRequiringBufferExpansion()
{
string s = new string('.', 4086);
var opts = FileDescriptorProto.CreateBuilder()
.SetName(s)
.SetPackage("package")
.BuildPartial();
Assert.NotNull(Extensions.ToJson(opts));
}
/// <summary>
/// Starts an extgensions block
/// </summary>
protected override void WriteExtensionsHeader(GeneratorContext ctx, FileDescriptorProto file, ref object state)
{
var name = file?.Options?.GetOptions()?.ExtensionTypeName;
if (string.IsNullOrWhiteSpace(name))
{
name = "Extensions";
}
ctx.WriteLine($"{GetAccess(GetAccess(file))} static class {Escape(name)}").WriteLine("{").Indent();
}
public virtual UmlPackage CreateUmlPackage(FileDescriptorProto fileDescriptorProto)
{
/*
* UmlPackage umlPackage = new UmlPackage(fileDescriptorProto.Package);
* UmlModel umlModel = CreateUmlModel(fileDescriptorProto);
* umlPackage.UmlModel = umlModel;
* return umlPackage;
*/
return(null);
}
/// <summary>
/// End a file
/// </summary>
protected override void WriteFileFooter(GeneratorContext ctx, FileDescriptorProto file, ref object state)
{
var @namespace = (string)state;
if (!string.IsNullOrEmpty(@namespace))
{
ctx.Outdent().WriteLine("}").WriteLine();
}
//ctx.WriteLine("#pragma warning restore CS1591, CS0612, CS3021");
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FileDescriptorProto DeserializeLength(Stream stream, int length)
{
FileDescriptorProto instance = new FileDescriptorProto();
DeserializeLength(stream, length, instance);
return instance;
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, FileDescriptorProto instance)
{
var msField = global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Pop();
if (instance.Name != null)
{
// Key for field: 1, LengthDelimited
stream.WriteByte(10);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Name));
}
if (instance.Package != null)
{
// Key for field: 2, LengthDelimited
stream.WriteByte(18);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Package));
}
if (instance.Dependency != null)
{
foreach (var i3 in instance.Dependency)
{
// Key for field: 3, LengthDelimited
stream.WriteByte(26);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(i3));
}
}
if (instance.PublicDependency != null)
{
foreach (var i10 in instance.PublicDependency)
{
// Key for field: 10, Varint
stream.WriteByte(80);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)i10);
}
}
if (instance.WeakDependency != null)
{
foreach (var i11 in instance.WeakDependency)
{
// Key for field: 11, Varint
stream.WriteByte(88);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)i11);
}
}
if (instance.MessageType != null)
{
foreach (var i4 in instance.MessageType)
{
// Key for field: 4, LengthDelimited
stream.WriteByte(34);
msField.SetLength(0);
Google.Protobuf.DescriptorProto.Serialize(msField, i4);
// Length delimited byte array
uint length4 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length4);
msField.WriteTo(stream);
}
}
if (instance.EnumType != null)
{
foreach (var i5 in instance.EnumType)
{
// Key for field: 5, LengthDelimited
stream.WriteByte(42);
msField.SetLength(0);
Google.Protobuf.EnumDescriptorProto.Serialize(msField, i5);
// Length delimited byte array
uint length5 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length5);
msField.WriteTo(stream);
}
}
if (instance.Service != null)
{
foreach (var i6 in instance.Service)
{
// Key for field: 6, LengthDelimited
stream.WriteByte(50);
msField.SetLength(0);
Google.Protobuf.ServiceDescriptorProto.Serialize(msField, i6);
// Length delimited byte array
uint length6 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length6);
msField.WriteTo(stream);
}
}
if (instance.Extension != null)
{
foreach (var i7 in instance.Extension)
{
// Key for field: 7, LengthDelimited
stream.WriteByte(58);
msField.SetLength(0);
Google.Protobuf.FieldDescriptorProto.Serialize(msField, i7);
// Length delimited byte array
uint length7 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length7);
msField.WriteTo(stream);
}
}
if (instance.Options != null)
{
// Key for field: 8, LengthDelimited
stream.WriteByte(66);
msField.SetLength(0);
Google.Protobuf.FileOptions.Serialize(msField, instance.Options);
// Length delimited byte array
uint length8 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length8);
msField.WriteTo(stream);
}
if (instance.SourceCodeInfo != null)
{
// Key for field: 9, LengthDelimited
stream.WriteByte(74);
msField.SetLength(0);
Google.Protobuf.SourceCodeInfo.Serialize(msField, instance.SourceCodeInfo);
// Length delimited byte array
uint length9 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length9);
msField.WriteTo(stream);
}
global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Push(msField);
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FileDescriptorProto Deserialize(Stream stream)
{
var instance = new FileDescriptorProto();
Deserialize(stream, instance);
return instance;
}
/// <summary>Helper: put the buffer into a MemoryStream and create a new instance to deserializing into</summary>
public static FileDescriptorProto Deserialize(byte[] buffer)
{
FileDescriptorProto instance = new FileDescriptorProto();
using (var ms = new MemoryStream(buffer))
Deserialize(ms, instance);
return instance;
}
/// <summary>Helper: Serialize into a MemoryStream and return its byte array</summary>
public static byte[] SerializeToBytes(FileDescriptorProto instance)
{
using (var ms = new MemoryStream())
{
Serialize(ms, instance);
return ms.ToArray();
}
}
/// <summary>Helper: Serialize with a varint length prefix</summary>
public static void SerializeLengthDelimited(Stream stream, FileDescriptorProto instance)
{
var data = SerializeToBytes(instance);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, (uint)data.Length);
stream.Write(data, 0, data.Length);
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, FileDescriptorProto instance)
{
if (instance.Name != null)
{
// Key for field: 1, LengthDelimited
stream.WriteByte(10);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Name));
}
if (instance.Package != null)
{
// Key for field: 2, LengthDelimited
stream.WriteByte(18);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Package));
}
if (instance.Dependency != null)
{
foreach (var i3 in instance.Dependency)
{
// Key for field: 3, LengthDelimited
stream.WriteByte(26);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(i3));
}
}
if (instance.PublicDependency != null)
{
foreach (var i10 in instance.PublicDependency)
{
// Key for field: 10, Varint
stream.WriteByte(80);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)i10);
}
}
if (instance.WeakDependency != null)
{
foreach (var i11 in instance.WeakDependency)
{
// Key for field: 11, Varint
stream.WriteByte(88);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt64(stream,(ulong)i11);
}
}
if (instance.MessageType != null)
{
foreach (var i4 in instance.MessageType)
{
// Key for field: 4, LengthDelimited
stream.WriteByte(34);
using (var ms4 = new MemoryStream())
{
Google.protobuf.DescriptorProto.Serialize(ms4, i4);
// Length delimited byte array
uint ms4Length = (uint)ms4.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms4Length);
stream.Write(ms4.GetBuffer(), 0, (int)ms4Length);
}
}
}
if (instance.EnumType != null)
{
foreach (var i5 in instance.EnumType)
{
// Key for field: 5, LengthDelimited
stream.WriteByte(42);
using (var ms5 = new MemoryStream())
{
Google.protobuf.EnumDescriptorProto.Serialize(ms5, i5);
// Length delimited byte array
uint ms5Length = (uint)ms5.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms5Length);
stream.Write(ms5.GetBuffer(), 0, (int)ms5Length);
}
}
}
if (instance.Service != null)
{
foreach (var i6 in instance.Service)
{
// Key for field: 6, LengthDelimited
stream.WriteByte(50);
using (var ms6 = new MemoryStream())
{
Google.protobuf.ServiceDescriptorProto.Serialize(ms6, i6);
// Length delimited byte array
uint ms6Length = (uint)ms6.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms6Length);
stream.Write(ms6.GetBuffer(), 0, (int)ms6Length);
}
}
}
if (instance.Extension != null)
{
foreach (var i7 in instance.Extension)
{
// Key for field: 7, LengthDelimited
stream.WriteByte(58);
using (var ms7 = new MemoryStream())
{
Google.protobuf.FieldDescriptorProto.Serialize(ms7, i7);
// Length delimited byte array
uint ms7Length = (uint)ms7.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms7Length);
stream.Write(ms7.GetBuffer(), 0, (int)ms7Length);
}
}
}
if (instance.Options != null)
{
// Key for field: 8, LengthDelimited
stream.WriteByte(66);
using (var ms8 = new MemoryStream())
{
Google.protobuf.FileOptions.Serialize(ms8, instance.Options);
// Length delimited byte array
uint ms8Length = (uint)ms8.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms8Length);
stream.Write(ms8.GetBuffer(), 0, (int)ms8Length);
}
}
if (instance.SourceCodeInfo != null)
{
// Key for field: 9, LengthDelimited
stream.WriteByte(74);
using (var ms9 = new MemoryStream())
{
Google.protobuf.SourceCodeInfo.Serialize(ms9, instance.SourceCodeInfo);
// Length delimited byte array
uint ms9Length = (uint)ms9.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms9Length);
stream.Write(ms9.GetBuffer(), 0, (int)ms9Length);
}
}
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FileDescriptorProto DeserializeLengthDelimited(Stream stream)
{
FileDescriptorProto instance = new FileDescriptorProto();
DeserializeLengthDelimited(stream, instance);
return instance;
}
