コード例 #1
0
        /// <summary>
        /// Start an enum
        /// </summary>
        protected override void WriteEnumHeader(GeneratorContext ctx, EnumDescriptorProto obj, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(obj);
            var tw   = ctx.Write($@"[global::ProtoBuf.ProtoContract(");

            if (name != obj.Name)
            {
                tw.Write($@"Name = @""{obj.Name}""");
            }
            tw.WriteLine(")]");
            WriteOptions(ctx, obj.Options);
            ctx.WriteLine($"{GetAccess(GetAccess(obj))} enum {Escape(name)}").WriteLine("{").Indent();
        }
コード例 #2
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("End Namespace").WriteLine();
            }
            if (ctx.Supports(VB14))
            {
                ctx.WriteLine($"#Enable Warning BC40008, BC40055, IDE1006").WriteLine();
            }
        }
コード例 #3
0
        /// <summary>
        /// Emit code beginning a constructor, if one is required
        /// </summary>
        /// <returns>true if a constructor is required</returns>
        protected override bool WriteContructorHeader(GeneratorContext ctx, DescriptorProto message, ref object state)
        {
            if (ctx.Supports(CSharp6))
            {
                return(false);
            }

            var name = ctx.NameNormalizer.GetName(message);

            ctx.WriteLine($"public {Escape(name)}()") // note: the .ctor is still public even if the type is internal; it is protected by the scope
            .WriteLine("{").Indent();
            return(true);
        }
コード例 #4
0
        /// <summary>
        /// Start an enum
        /// </summary>
        protected override void WriteEnumHeader(GeneratorContext ctx, EnumDescriptorProto @enum, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(@enum);
            var tw   = ctx.Write("<Global.ProtoBuf.ProtoContract(");

            if (name != @enum.Name)
            {
                tw.Write($@"Name := ""{@enum.Name}""");
            }
            tw.WriteLine(")> _");
            WriteOptions(ctx, @enum.Options);
            ctx.WriteLine($"{GetAccess(GetAccess(@enum))} Enum {Escape(name)}").Indent();
        }
コード例 #5
0
        /// <summary>
        /// Write an extension
        /// </summary>
        protected override void WriteExtension(GeneratorContext ctx, FieldDescriptorProto field)
        {
            var type = GetTypeName(ctx, field, out string dataFormat, out bool isMap);

            if (isMap)
            {
                ctx.WriteLine("REM #error map extensions not yet implemented; please file an issue");
            }
            else if (field.label == FieldDescriptorProto.Label.LabelRepeated)
            {
                ctx.WriteLine("REM #error repeated extensions not yet implemented; please file an issue");
            }
            else
            {
                var msg      = ctx.TryFind <DescriptorProto>(field.Extendee);
                var extendee = MakeRelativeName(field, msg, ctx.NameNormalizer);

                string name   = ctx.NameNormalizer.GetName(field);
                string shared = "";
                if (field.Parent is FileDescriptorProto)
                {
                    ctx.WriteLine("<Global.System.Runtime.CompilerServices.Extension> _");
                }
                else
                {
                    shared = "Shared ";
                }
                ctx.WriteLine($"{GetAccess(GetAccess(field))} {shared}Function Get{name}(ByVal obj As {extendee}) As {type}");

                var tw = ctx.Indent().Write($"Return If(obj Is Nothing, CType(Nothing, {type}), Global.ProtoBuf.Extensible.GetValue(Of {type})(obj, {field.Number}");
                if (!string.IsNullOrEmpty(dataFormat))
                {
                    tw.Write($", Global.ProtoBuf.DataFormat.{dataFormat}");
                }
                tw.WriteLine("))");
                ctx.Outdent().WriteLine("End Function");
            }
        }
コード例 #6
0
        /// <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("// 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()
                         .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();
            }
        }
コード例 #7
0
        /// <summary>
        /// Write an enum value
        /// </summary>
        protected override void WriteEnumValue(GeneratorContext ctx, EnumValueDescriptorProto @enum, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(@enum);

            if (name != @enum.Name)
            {
                var tw = ctx.Write("[global::ProtoBuf.ProtoEnum(");
                tw.Write($@"Name = @""{@enum.Name}""");
                tw.WriteLine(")]");
            }

            WriteOptions(ctx, @enum.Options);
            ctx.WriteLine($"{Escape(name)} = {@enum.Number},");
        }
コード例 #8
0
        /// <summary>
        /// Start a file
        /// </summary>
        protected override void WriteFileHeader(GeneratorContext ctx, FileDescriptorProto file, ref object state)
        {
            //var prefix = ctx.Supports(CSharp6) ? "CS" : "";
            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();

            if (ctx.Supports(VB14))
            {
                ctx.WriteLine($"#Disable Warning BC40008, BC40055, IDE1006").WriteLine();
            }

            var @namespace = ctx.NameNormalizer.GetName(file);

            if (!string.IsNullOrWhiteSpace(@namespace))
            {
                state = @namespace;
                ctx.WriteLine($"Namespace {@namespace}").Indent();
            }
        }
コード例 #9
0
        /// <summary>
        /// Write an enum value
        /// </summary>
        protected override void WriteEnumValue(GeneratorContext ctx, EnumValueDescriptorProto obj, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(obj);

            if (name != obj.Name)
            {
                var tw = ctx.Write($@"<Global.ProtoBuf.ProtoEnum(");
                tw.Write($@"Name := ""{obj.Name}""");
                tw.WriteLine(")> _");
            }

            WriteOptions(ctx, obj.Options);
            ctx.WriteLine($"{Escape(name)} = {obj.Number}");
        }
コード例 #10
0
        /// <summary>
        /// Emit code initializing field values inside a constructor, if one is required
        /// </summary>
        protected override void WriteInitField(GeneratorContext ctx, FieldDescriptorProto field, ref object state, OneOfStub[] oneOfs)
        {
            var       name           = ctx.NameNormalizer.GetName(field);
            bool      isOptional     = field.label == FieldDescriptorProto.Label.LabelOptional;
            bool      isRepeated     = field.label == FieldDescriptorProto.Label.LabelRepeated;
            var       typeName       = GetTypeName(ctx, field, out var dataFormat, out var isMap);
            OneOfStub oneOf          = field.ShouldSerializeOneofIndex() ? oneOfs?[field.OneofIndex] : null;
            bool      explicitValues = isOptional && oneOf == null && ctx.Syntax == FileDescriptorProto.SyntaxProto2 &&
                                       field.type != FieldDescriptorProto.Type.TypeMessage &&
                                       field.type != FieldDescriptorProto.Type.TypeGroup;

            string defaultValue = GetDefaultValue(ctx, field, typeName);

            if (isRepeated)
            {
                var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(field.TypeName) : null;
                if (mapMsgType != null)
                {
                    var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
                                                  out var keyDataFormat, out var _);
                    var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
                                                    out var valueDataFormat, out var _);
                    ctx.WriteLine($"{Escape(name)} = new global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}>();");
                }
                else if (!UseArray(field))
                {
                    ctx.WriteLine($"{Escape(name)} = new global::System.Collections.Generic.List<{typeName}>();");
                }
            }
            else if (oneOf == null && !explicitValues)
            {
                if (!string.IsNullOrWhiteSpace(defaultValue))
                {
                    ctx.WriteLine($"{Escape(name)} = {defaultValue};");
                }
            }
        }
コード例 #11
0
        /// <summary>
        /// Start a message
        /// </summary>
        protected override void WriteMessageHeader(GeneratorContext ctx, DescriptorProto obj, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(obj);
            var tw   = ctx.Write($@"[global::ProtoBuf.ProtoContract(");

            if (name != obj.Name)
            {
                tw.Write($@"Name = @""{obj.Name}""");
            }
            tw.WriteLine(")]");
            WriteOptions(ctx, obj.Options);
            tw = ctx.Write($"{GetAccess(GetAccess(obj))} partial class {Escape(name)}");
            if (obj.ExtensionRanges.Count != 0)
            {
                tw.Write(" : global::ProtoBuf.IExtensible");
            }
            tw.WriteLine();
            ctx.WriteLine("{").Indent();
            if (obj.Options?.MessageSetWireFormat == true)
            {
                ctx.WriteLine("#error message_set_wire_format is not currently implemented").WriteLine();
            }
            if (obj.ExtensionRanges.Count != 0)
            {
                ctx.WriteLine($"private global::ProtoBuf.IExtension {FieldPrefix}extensionData;")
                .WriteLine($"global::ProtoBuf.IExtension global::ProtoBuf.IExtensible.GetExtensionObject(bool createIfMissing)");

                if (ctx.Supports(CSharp6))
                {
                    ctx.Indent().WriteLine($"=> global::ProtoBuf.Extensible.GetExtensionObject(ref {FieldPrefix}extensionData, createIfMissing);").Outdent().WriteLine();
                }
                else
                {
                    ctx.WriteLine("{").Indent().WriteLine($"return global::ProtoBuf.Extensible.GetExtensionObject(ref {FieldPrefix}extensionData, createIfMissing);").Outdent().WriteLine("}");
                }
            }
        }
コード例 #12
0
        /// <summary>
        /// Start a message
        /// </summary>
        protected override void WriteMessageHeader(GeneratorContext ctx, DescriptorProto message, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(message);
            var tw   = ctx.Write("<Global.ProtoBuf.ProtoContract(");

            if (name != message.Name)
            {
                tw.Write($@"Name := ""{message.Name}""");
            }
            tw.WriteLine(")> _");
            WriteOptions(ctx, message.Options);
            ctx.WriteLine($"Partial {GetAccess(GetAccess(message))} Class {Escape(name)}");
            ctx.Indent().WriteLine("Implements Global.ProtoBuf.IExtensible").WriteLine();

            if (message.Options?.MessageSetWireFormat == true)
            {
                ctx.WriteLine("REM #error message_set_wire_format is not currently implemented").WriteLine();
            }

            ctx.WriteLine($"Private {FieldPrefix}extensionData As Global.ProtoBuf.IExtension").WriteLine()
            .WriteLine($"Private Function GetExtensionObject(ByVal createIfMissing As Boolean) As Global.ProtoBuf.IExtension Implements Global.ProtoBuf.IExtensible.GetExtensionObject")
            .Indent().WriteLine($"Return Global.ProtoBuf.Extensible.GetExtensionObject({FieldPrefix}extensionData, createIfMissing)")
            .Outdent().WriteLine("End Function").WriteLine();
        }
コード例 #13
0
        /// <summary>
        /// Start a file
        /// </summary>
        protected override void WriteFileHeader(GeneratorContext ctx, FileDescriptorProto file, ref object state)
        {
            ctx.WriteLine("// ***** This is for GAME_MASTER files. *****");

            string version = ctx.GetCustomOption("PROTO_VERSION");

            if (version != null)
            {
                version = "v" + version.Replace('.', '_');
                int pos = file.Package.IndexOf('.');
                file.Package = pos == -1 ?
                               file.Package + '.' + version :
                               file.Package.Substring(0, pos) + '.' + version + file.Package.Substring(pos);
            }

            base.WriteFileHeader(ctx, file, ref state);
        }
コード例 #14
0
        /// <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}0618, {prefix}1591, {prefix}3021");

            if (ctx.Supports(CSharp6))
            {
                tw.Write(AdditionalSuppressionCodes);
            }
            tw.WriteLine();
        }
コード例 #15
0
ファイル: ILCodeGen.cs プロジェクト: uncaha/ProtoToCS
        protected override void WriteReadFun(GeneratorContext ctx, DescriptorProto obj, OneOfStub[] oneOfs)
        {
            ctx.WriteLine($"public void MergeFrom(byte[] _bytes){"{"}").Indent();
            ctx.WriteLine("Google.Protobuf.CodedInputStream input = new Google.Protobuf.CodedInputStream(_bytes);");
            ctx.WriteLine("uint tag;");
            ctx.WriteLine("while ((tag = input.ReadTag()) != 0) {").Indent();
            ctx.WriteLine("switch(tag) {").Indent();
            ctx.WriteLine("default:").Indent();
            ctx.WriteLine("input.SkipLastField();");
            ctx.WriteLine("break;").Outdent();

            foreach (var inner in obj.Fields)
            {
                WriteFileRead(ctx, inner, oneOfs);
            }

            ctx.Outdent().WriteLine("}"); //switch

            ctx.Outdent().WriteLine("}"); //while

            ctx.WriteLine("input.Dispose();");

            ctx.Outdent().WriteLine("}");
        }
コード例 #16
0
        => obj.Options?.MapEntry ?? false;     // don't write this type - use a dictionary instead

        /// <summary>
        /// Emit code representing a message type
        /// </summary>
        protected virtual void WriteMessage(GeneratorContext ctx, DescriptorProto obj)
        {
            object state = null;

            if (ShouldOmitMessage(ctx, obj, ref state))
            {
                return;
            }

            WriteMessageHeader(ctx, obj, ref state);
            var oneOfs = OneOfStub.Build(ctx, obj);

            ctx.WriteLine("#region 属性");
            foreach (var inner in obj.Fields)
            {
                WriteField(ctx, inner, ref state, oneOfs);
            }
            ctx.WriteLine("#endregion");

            ctx.WriteLine("#region 定义");
            foreach (var inner in obj.NestedTypes)
            {
                WriteMessage(ctx, inner);
            }
            foreach (var inner in obj.EnumTypes)
            {
                WriteEnum(ctx, inner);
            }
            if (obj.Extensions.Count != 0)
            {
                object extState = null;
                WriteExtensionsHeader(ctx, obj, ref extState);
                foreach (var ext in obj.Extensions)
                {
                    WriteExtension(ctx, ext);
                }
                WriteExtensionsFooter(ctx, obj, ref extState);
            }
            ctx.WriteLine("#endregion");

            ctx.WriteLine("#region 读取写入");
            WriteReadFun(ctx, obj, oneOfs);
            WriteWriteFun(ctx, obj, oneOfs);
            ctx.WriteLine("#endregion");


            WriteMessageFooter(ctx, obj, ref state);
        }
コード例 #17
0
        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, i) => new ProtoMethod
                    {
                        Index      = i,
                        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);
        }
コード例 #18
0
        /// <summary>
        /// Emit a field-based entry for a 'oneof' groups's enum
        /// </summary>
        protected override void WriteOneOfEnumValue(GeneratorContext ctx, FieldDescriptorProto field, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(field);

            ctx.WriteLine($"{Escape(name)} = {field.Number},");
        }
コード例 #19
0
 /// <summary>
 /// Emit the start of an enum declaration for 'oneof' groups, including the 0/None element
 /// </summary>
 protected override void WriteOneOfEnumHeader(GeneratorContext ctx, OneofDescriptorProto oneof, ref object state)
 {
     ctx.WriteLine().WriteLine($"public enum {ctx.NameNormalizer.GetName(oneof)}{OneOfEnumSuffixEnum}").WriteLine("{").Indent().WriteLine("None = 0,");
 }
コード例 #20
0
        /// <summary>
        /// Write an extension
        /// </summary>
        protected override void WriteExtension(GeneratorContext ctx, FieldDescriptorProto field)
        {
            var type            = GetTypeName(ctx, field, out string dataFormat, out bool isMap, false);
            var nonNullableType = GetTypeName(ctx, field, out _, out _, true);
            var msg             = ctx.TryFind <DescriptorProto>(field.Extendee);
            var extendee        = MakeRelativeName(field, msg, ctx.NameNormalizer);

            var        @this = field.Parent is FileDescriptorProto ? "this " : "";
            string     name  = ctx.NameNormalizer.GetName(field);
            TextWriter tw;

            if (isMap)
            {
                ctx.WriteLine("#error map extensions not yet implemented; please file an issue");
            }
            else
            {
                bool isRepeated = field.label == FieldDescriptorProto.Label.LabelRepeated;

                var getMethodName = isRepeated ? nameof(Extensible.GetValues) : nameof(Extensible.GetValue);
                if (isRepeated)
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} static global::System.Collections.Generic.IEnumerable<{nonNullableType}> Get{name}({@this}{extendee} obj)");
                }
                else
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} static {type} Get{name}({@this}{extendee} obj)");
                }
                if (ctx.Supports(CSharp6))
                {
                    tw = ctx.Indent().Write($"=> ");
                }
                else
                {
                    ctx.WriteLine("{").Indent();
                    tw = ctx.Write("return ");
                }
                var defaultValue = isRepeated ? "null" : ctx.Supports(CSharp7_1) ? "default" : $"default({type})";
                tw.Write($"obj == null ? {defaultValue} : global::ProtoBuf.Extensible.{getMethodName}<{(isRepeated ? nonNullableType : type)}>(obj, {field.Number}");
                if (!string.IsNullOrEmpty(dataFormat))
                {
                    tw.Write($", global::ProtoBuf.DataFormat.{dataFormat}");
                }
                tw.WriteLine(");");
                if (ctx.Supports(CSharp6))
                {
                    ctx.Outdent().WriteLine();
                }
                else
                {
                    ctx.Outdent().WriteLine("}").WriteLine();
                }

                var setAccessorName = isRepeated ? "Add" : "Set";
                ctx.WriteLine($"{GetAccess(GetAccess(field))} static void {setAccessorName}{name}({@this}{extendee} obj, {nonNullableType} value)");
                if (ctx.Supports(CSharp6))
                {
                    tw = ctx.Indent().Write($"=> ");
                }
                else
                {
                    ctx.WriteLine("{").Indent();
                    tw = ctx.Write("");
                }
                tw.Write($"global::ProtoBuf.Extensible.AppendValue<{nonNullableType}>(obj, {field.Number}");
                if (!string.IsNullOrEmpty(dataFormat))
                {
                    tw.Write($", global::ProtoBuf.DataFormat.{dataFormat}");
                }
                tw.WriteLine(", value);");
                if (ctx.Supports(CSharp6))
                {
                    ctx.Outdent().WriteLine();
                }
                else
                {
                    ctx.Outdent().WriteLine("}").WriteLine();
                }
            }
        }
コード例 #21
0
        /// <summary>
        /// Write a field
        /// </summary>
        protected override void WriteField(GeneratorContext ctx, FieldDescriptorProto field, ref object state, OneOfStub[] oneOfs)
        {
            var name = ctx.NameNormalizer.GetName(field);
            var tw   = ctx.Write($"[global::ProtoBuf.ProtoMember({field.Number}");

            if (name != field.Name)
            {
                tw.Write($@", Name = @""{field.Name}""");
            }
            var options = field.Options?.GetOptions();

            if (options?.AsReference == true)
            {
                tw.Write(", AsReference = true");
            }
            if (options?.DynamicType == true)
            {
                tw.Write(", DynamicType = true");
            }

            bool isOptional = field.label == FieldDescriptorProto.Label.LabelOptional;
            bool isRepeated = field.label == FieldDescriptorProto.Label.LabelRepeated;

            OneOfStub oneOf = field.ShouldSerializeOneofIndex() ? oneOfs?[field.OneofIndex] : null;

            if (oneOf != null && !ctx.OneOfEnums && oneOf.CountTotal == 1)
            {
                oneOf = null; // not really a one-of, then!
            }
            bool explicitValues = isOptional && oneOf == null && ctx.Syntax == FileDescriptorProto.SyntaxProto2 &&
                                  field.type != FieldDescriptorProto.Type.TypeMessage &&
                                  field.type != FieldDescriptorProto.Type.TypeGroup;

            bool   suppressDefaultAttribute = !isOptional;
            var    typeName     = GetTypeName(ctx, field, out var dataFormat, out var isMap);
            string defaultValue = GetDefaultValue(ctx, field, typeName);

            if (!string.IsNullOrWhiteSpace(dataFormat))
            {
                tw.Write($", DataFormat = global::ProtoBuf.DataFormat.{dataFormat}");
            }
            if (field.IsPacked(ctx.Syntax))
            {
                tw.Write($", IsPacked = true");
            }
            if (field.label == FieldDescriptorProto.Label.LabelRequired)
            {
                tw.Write($", IsRequired = true");
            }
            tw.WriteLine(")]");
            if (!isRepeated && !string.IsNullOrWhiteSpace(defaultValue) && !suppressDefaultAttribute)
            {
                ctx.WriteLine($"[global::System.ComponentModel.DefaultValue({defaultValue})]");
            }
            WriteOptions(ctx, field.Options);
            if (isRepeated)
            {
                var  mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(field.TypeName) : null;
                bool allowSet   = ctx.EmitListSetters;
                if (mapMsgType != null)
                {
                    var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
                                                  out var keyDataFormat, out var _);
                    var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
                                                    out var valueDataFormat, out var _);

                    bool first = true;
                    tw = ctx.Write($"[global::ProtoBuf.ProtoMap");
                    if (!string.IsNullOrWhiteSpace(keyDataFormat))
                    {
                        tw.Write($"{(first ? "(" : ", ")}KeyFormat = global::ProtoBuf.DataFormat.{keyDataFormat}");
                        first = false;
                    }
                    if (!string.IsNullOrWhiteSpace(valueDataFormat))
                    {
                        tw.Write($"{(first ? "(" : ", ")}ValueFormat = global::ProtoBuf.DataFormat.{valueDataFormat}");
                        first = false;
                    }
                    tw.WriteLine(first ? "]" : ")]");
                    if (ctx.Supports(CSharp6))
                    {
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}> {Escape(name)} {{ get; {(allowSet ? "set; " : "")}}} = new global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}>();");
                    }
                    else
                    {
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}> {Escape(name)} {{ get; {(allowSet ? "" : "private ")}set; }}");
                    }
                }
                else if (UseArray(field))
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} {typeName}[] {Escape(name)} {{ get; set; }}");
                }
                else if (ctx.Supports(CSharp6))
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} global::System.Collections.Generic.List<{typeName}> {Escape(name)} {{ get; {(allowSet ? "set; " : "")}}} = new global::System.Collections.Generic.List<{typeName}>();");
                }
                else
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} global::System.Collections.Generic.List<{typeName}> {Escape(name)} {{ get; {(allowSet ? "" : "private ")}set; }}");
                }
            }
            else if (oneOf != null)
            {
                var defValue  = string.IsNullOrWhiteSpace(defaultValue) ? (ctx.Supports(CSharp7_1) ? "default" : $"default({typeName})") : defaultValue;
                var fieldName = GetOneOfFieldName(oneOf.OneOf);
                var storage   = oneOf.GetStorage(field.type, field.TypeName);
                ctx.WriteLine($"{GetAccess(GetAccess(field))} {typeName} {Escape(name)}").WriteLine("{").Indent();

                switch (field.type)
                {
                case FieldDescriptorProto.Type.TypeMessage:
                case FieldDescriptorProto.Type.TypeGroup:
                case FieldDescriptorProto.Type.TypeEnum:
                case FieldDescriptorProto.Type.TypeBytes:
                case FieldDescriptorProto.Type.TypeString:
                    ctx.WriteLine($"get {{ return {fieldName}.Is({field.Number}) ? (({typeName}){fieldName}.{storage}) : {defValue}; }}");
                    break;

                default:
                    ctx.WriteLine($"get {{ return {fieldName}.Is({field.Number}) ? {fieldName}.{storage} : {defValue}; }}");
                    break;
                }
                var unionType = oneOf.GetUnionType();
                var cast      = field.type == FieldDescriptorProto.Type.TypeEnum ? "(int)" : "";
                ctx.WriteLine($"set {{ {fieldName} = new global::ProtoBuf.{unionType}({field.Number}, {cast}value); }}")
                .Outdent().WriteLine("}");

                if (ctx.Supports(CSharp6))
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} bool ShouldSerialize{name}() => {fieldName}.Is({field.Number});")
                    .WriteLine($"{GetAccess(GetAccess(field))} void Reset{name}() => global::ProtoBuf.{unionType}.Reset(ref {fieldName}, {field.Number});");
                }
                else
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} bool ShouldSerialize{name}()").WriteLine("{").Indent()
                    .WriteLine($"return {fieldName}.Is({field.Number});").Outdent().WriteLine("}")
                    .WriteLine($"{GetAccess(GetAccess(field))} void Reset{name}()").WriteLine("{").Indent()
                    .WriteLine($"global::ProtoBuf.{unionType}.Reset(ref {fieldName}, {field.Number});").Outdent().WriteLine("}");
                }

                if (oneOf.IsFirst())
                {
                    ctx.WriteLine().WriteLine($"private global::ProtoBuf.{unionType} {fieldName};");
                }
            }
            else if (explicitValues)
            {
                string fieldName = FieldPrefix + name, fieldType;
                bool   isRef = false;
                switch (field.type)
                {
                case FieldDescriptorProto.Type.TypeString:
                case FieldDescriptorProto.Type.TypeBytes:
                    fieldType = typeName;
                    isRef     = true;
                    break;

                default:
                    fieldType = typeName + "?";
                    break;
                }
                ctx.WriteLine($"{GetAccess(GetAccess(field))} {typeName} {Escape(name)}").WriteLine("{").Indent();
                tw = ctx.Write($"get {{ return {fieldName}");
                if (!string.IsNullOrWhiteSpace(defaultValue))
                {
                    tw.Write(" ?? ");
                    tw.Write(defaultValue);
                }
                else if (!isRef)
                {
                    tw.Write(".GetValueOrDefault()");
                }
                tw.WriteLine("; }");
                ctx.WriteLine($"set {{ {fieldName} = value; }}")
                .Outdent().WriteLine("}");
                if (ctx.Supports(CSharp6))
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} bool ShouldSerialize{name}() => {fieldName} != null;")
                    .WriteLine($"{GetAccess(GetAccess(field))} void Reset{name}() => {fieldName} = null;");
                }
                else
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(field))} bool ShouldSerialize{name}()").WriteLine("{").Indent()
                    .WriteLine($"return {fieldName} != null;").Outdent().WriteLine("}")
                    .WriteLine($"{GetAccess(GetAccess(field))} void Reset{name}()").WriteLine("{").Indent()
                    .WriteLine($"{fieldName} = null;").Outdent().WriteLine("}");
                }
                ctx.WriteLine($"private {fieldType} {fieldName};");
            }
            else
            {
                tw = ctx.Write($"{GetAccess(GetAccess(field))} {typeName} {Escape(name)} {{ get; set; }}");
                if (!string.IsNullOrWhiteSpace(defaultValue) && ctx.Supports(CSharp6))
                {
                    tw.Write($" = {defaultValue};");
                }
                tw.WriteLine();
            }
            ctx.WriteLine();
        }
コード例 #22
0
        /// <summary>
        /// Write a field
        /// </summary>
        protected override void WriteField(GeneratorContext ctx, FieldDescriptorProto field, ref object state, OneOfStub[] oneOfs)
        {
            var name = ctx.NameNormalizer.GetName(field);

            var tw = ctx.Write($"<Global.ProtoBuf.ProtoMember({field.Number}");

            if (name != field.Name)
            {
                tw.Write($@", Name := ""{field.Name}""");
            }
            var options = field.Options?.GetOptions();

            if (options?.AsReference == true)
            {
                tw.Write(", AsReference := True");
            }
            if (options?.DynamicType == true)
            {
                tw.Write(", DynamicType := True");
            }

            bool isOptional = field.label == FieldDescriptorProto.Label.LabelOptional;
            bool isRepeated = field.label == FieldDescriptorProto.Label.LabelRepeated;

            OneOfStub oneOf = field.ShouldSerializeOneofIndex() ? oneOfs?[field.OneofIndex] : null;

            if (oneOf != null && !ctx.OneOfEnums && oneOf.CountTotal == 1)
            {
                oneOf = null; // not really a one-of, then!
            }
            bool explicitValues = isOptional && oneOf == null && ctx.Syntax == FileDescriptorProto.SyntaxProto2 &&
                                  field.type != FieldDescriptorProto.Type.TypeMessage &&
                                  field.type != FieldDescriptorProto.Type.TypeGroup;

            bool suppressDefaultAttribute = !isOptional;
            var  typeName = GetTypeName(ctx, field, out var dataFormat, out var isMap);

            string defaultValue = GetDefaultValue(ctx, field, typeName);

            if (!string.IsNullOrWhiteSpace(dataFormat))
            {
                tw.Write($", DataFormat := Global.ProtoBuf.DataFormat.{dataFormat}");
            }
            if (field.IsPacked(ctx.Syntax))
            {
                tw.Write($", IsPacked := True");
            }
            if (field.label == FieldDescriptorProto.Label.LabelRequired)
            {
                tw.Write($", IsRequired := True");
            }
            tw.WriteLine(")> _");
            if (!isRepeated && !string.IsNullOrWhiteSpace(defaultValue) && !suppressDefaultAttribute)
            {
                ctx.WriteLine($"<Global.System.ComponentModel.DefaultValue({defaultValue})> _");
            }
            WriteOptions(ctx, field.Options);
            if (isRepeated)
            {
                var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(field.TypeName) : null;
                if (mapMsgType != null)
                {
                    var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
                                                  out var keyDataFormat, out var _);
                    var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
                                                    out var valueDataFormat, out var _);

                    bool first = true;
                    tw = ctx.Write($"<Global.ProtoBuf.ProtoMap");
                    if (!string.IsNullOrWhiteSpace(keyDataFormat))
                    {
                        tw.Write($"{(first ? "(" : ", ")}KeyFormat := Global.ProtoBuf.DataFormat.{keyDataFormat}");
                        first = false;
                    }
                    if (!string.IsNullOrWhiteSpace(valueDataFormat))
                    {
                        tw.Write($"{(first ? "(" : ", ")}ValueFormat := Global.ProtoBuf.DataFormat.{valueDataFormat}");
                        first = false;
                    }
                    tw.WriteLine(first ? "> _" : ")> _");

                    if (ctx.Supports(VB14))
                    {
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} Readonly Property {Escape(name)} As New Global.System.Collections.Generic.Dictionary(Of {keyTypeName}, {valueTypeName})");
                    }
                    else
                    {
                        var fieldName = FieldPrefix + name;
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} Readonly Property {Escape(name)} As Global.System.Collections.Generic.Dictionary(Of {keyTypeName}, {valueTypeName})").Indent()
                        .WriteLine("Get").Indent()
                        .WriteLine($"Return {fieldName}")
                        .Outdent().WriteLine("End Get").Outdent().WriteLine("End Property").WriteLine()
                        .WriteLine($"Private ReadOnly {fieldName} As New Global.System.Collections.Generic.Dictionary(Of {keyTypeName}, {valueTypeName})").WriteLine();
                    }
                }
                else if (UseArray(field))
                {
                    if (ctx.Supports(VB11))
                    {
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} Property {Escape(name)} As {typeName}()");
                    }
                    else
                    {
                        var fieldName = FieldPrefix + name;
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} Property {Escape(name)} As {typeName}()")
                        .Indent().WriteLine("Get").Indent().WriteLine($"Return {fieldName}").Outdent().WriteLine("End Get").Outdent()
                        .Indent().WriteLine($"Set(ByVal value as {typeName}())").Indent().WriteLine($"{fieldName} = value").Outdent().WriteLine("End Set").Outdent()
                        .WriteLine("End Property").WriteLine()
                        .WriteLine($"Private {fieldName} As {typeName}()").WriteLine();
                    }
                }
                else
                {
                    if (ctx.Supports(VB14))
                    {
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} Readonly Property {Escape(name)} As New Global.System.Collections.Generic.List(Of {typeName})");
                    }
                    else
                    {
                        var fieldName = FieldPrefix + name;
                        ctx.WriteLine($"{GetAccess(GetAccess(field))} Readonly Property {Escape(name)} As Global.System.Collections.Generic.List(Of {typeName})").Indent()
                        .WriteLine("Get").Indent()
                        .WriteLine($"Return {fieldName}")
                        .Outdent().WriteLine("End Get").Outdent().WriteLine("End Property").WriteLine()
                        .WriteLine($"Private ReadOnly {fieldName} As New Global.System.Collections.Generic.List(Of {typeName})").WriteLine();
                    }
                }
            }
            else if (oneOf != null)
            {
                var defValue  = string.IsNullOrWhiteSpace(defaultValue) ? $"CType(Nothing, {typeName})" : defaultValue;
                var fieldName = GetOneOfFieldName(oneOf.OneOf);
                var storage   = oneOf.GetStorage(field.type, field.TypeName);
                ctx.WriteLine($"{GetAccess(GetAccess(field))} Property {Escape(name)} As {typeName}").Indent().WriteLine("Get").Indent();
                switch (field.type)
                {
                case FieldDescriptorProto.Type.TypeMessage:
                case FieldDescriptorProto.Type.TypeGroup:
                case FieldDescriptorProto.Type.TypeEnum:
                case FieldDescriptorProto.Type.TypeBytes:
                case FieldDescriptorProto.Type.TypeString:
                    ctx.WriteLine($"Return If({fieldName}.Is({field.Number}), CType({fieldName}.{storage}, {typeName}), {defValue})");
                    break;

                default:
                    ctx.WriteLine($"Return If({fieldName}.Is({field.Number}), {fieldName}.{storage}, {defValue})");
                    break;
                }
                ctx.Outdent().WriteLine("End Get");

                var unionType = oneOf.GetUnionType();

                ctx.WriteLine($"Set(ByVal value As {typeName})").Indent()
                .WriteLine($"{fieldName} = New Global.ProtoBuf.{unionType}({field.Number}, value)").Outdent().WriteLine("End Set");

                ctx.Outdent().WriteLine("End Property").WriteLine();

                ctx.WriteLine($"{GetAccess(GetAccess(field))} Function ShouldSerialize{name}() As Boolean").Indent()
                .WriteLine($"Return {fieldName}.Is({field.Number})").Outdent()
                .WriteLine("End Function").WriteLine()
                .WriteLine($"{GetAccess(GetAccess(field))} Sub Reset{name}()").Indent()
                .WriteLine($"Global.ProtoBuf.{unionType}.Reset({fieldName}, {field.Number})")
                .Outdent().WriteLine("End Sub");

                if (oneOf.IsFirst())
                {
                    ctx.WriteLine().WriteLine($"Private {fieldName} As Global.ProtoBuf.{unionType}");
                }
            }
            else if (explicitValues)
            {
                string fieldName = FieldPrefix + name, fieldType;
                bool   isRef = false;
                switch (field.type)
                {
                case FieldDescriptorProto.Type.TypeString:
                case FieldDescriptorProto.Type.TypeBytes:
                    fieldType = typeName;
                    isRef     = true;
                    break;

                default:
                    fieldType = typeName + "?";
                    break;
                }

                ctx.WriteLine($"{GetAccess(GetAccess(field))} Property {Escape(name)} As {typeName}").Indent()
                .WriteLine("Get").Indent();

                if (!string.IsNullOrWhiteSpace(defaultValue))
                {
                    ctx.WriteLine($"Return If({fieldName}, {defaultValue})");
                }
                else if (!isRef)
                {
                    ctx.WriteLine($"Return {fieldName}.GetValueOrDefault()");
                }
                else
                {
                    ctx.WriteLine($"Return {fieldName}");
                }

                ctx.Outdent().WriteLine("End Get").WriteLine($"Set(ByVal value As {typeName})").Indent()
                .WriteLine($"{fieldName} = value").Outdent().WriteLine("End Set").
                Outdent().WriteLine("End Property");

                ctx.WriteLine($"{GetAccess(GetAccess(field))} Function ShouldSerialize{name}() As Boolean").Indent()
                .WriteLine($"Return Not ({fieldName} Is Nothing)").Outdent()
                .WriteLine("End Function")
                .WriteLine($"{GetAccess(GetAccess(field))} Sub Reset{name}()").Indent()
                .WriteLine($"{fieldName} = Nothing").Outdent().WriteLine("End Sub");

                ctx.WriteLine($"Private {fieldName} As {fieldType}");
            }
            else
            {
                if (ctx.Supports(VB11))
                {
                    tw = ctx.Write($"{GetAccess(GetAccess(field))} Property {Escape(name)} As {typeName}");
                    if (!string.IsNullOrWhiteSpace(defaultValue))
                    {
                        tw.Write($" = {defaultValue}");
                    }
                    tw.WriteLine();
                }
                else
                {
                    var fieldName = FieldPrefix + name;
                    tw = ctx.WriteLine($"{GetAccess(GetAccess(field))} Property {Escape(name)} As {typeName}")
                         .Indent().WriteLine("Get").Indent().WriteLine($"Return {fieldName}").Outdent().WriteLine("End Get").Outdent()
                         .Indent().WriteLine($"Set(ByVal value as {typeName})").Indent().WriteLine($"{fieldName} = value").Outdent().WriteLine("End Set").Outdent()
                         .WriteLine("End Property").WriteLine()
                         .Write($"Private {fieldName} As {typeName}");
                    if (!string.IsNullOrWhiteSpace(defaultValue))
                    {
                        tw.Write($" = {defaultValue}");
                    }
                    tw.WriteLine();
                }
            }
            ctx.WriteLine();
        }
コード例 #23
0
ファイル: ILCodeGen.cs プロジェクト: uncaha/ProtoToCS
        protected void WriteFieldWrite(GeneratorContext ctx, FieldDescriptorProto obj, OneOfStub[] oneOfs)
        {
            bool isOptional = obj.label == FieldDescriptorProto.Label.LabelOptional;
            bool isRepeated = obj.label == FieldDescriptorProto.Label.LabelRepeated;

            Google.Protobuf.WireFormat.WireType ttwtype = ProtoTool.ILHelper.GetWireType(obj.type);
            uint   ttag   = Google.Protobuf.WireFormat.MakeTag(obj.Number, ttwtype);
            string tagstr = $"output.WriteTag({ttag});";

            var typeName = GetTypeName(ctx, obj, out var dataFormat, out var isMap);

            if (isOptional)
            {
                string tifvalue = "";
                if (obj.type == FieldDescriptorProto.Type.TypeString)
                {
                    tifvalue = $"if(!string.IsNullOrEmpty({obj.Name})){"{"}";
                }
                else
                {
                    tifvalue = $"if({obj.Name} != default({typeName})){"{"}";
                }
                ctx.WriteLine(tifvalue).Indent();
                //代码块
                ctx.WriteLine(tagstr);
                ctx.WriteLine(WriteString(obj.type, obj.Name));

                ctx.Outdent();
                ctx.WriteLine($"{"}"}");
            }
            else if (isRepeated)
            {
                var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(obj.TypeName) : null;
                if (mapMsgType != null)
                {
                    var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
                                                  out var keyDataFormat, out var _);
                    var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
                                                    out var valueDataFormat, out var _);
                    // System.Collections.Generic.Dictionary<int, int> ttt = new Dictionary<int, int>();
                    // System.Collections.Generic.KeyValuePair<int,int> ttt
                    ctx.WriteLine($"if({obj.Name}.Count > 0 ){"{"}").Indent();
                    ctx.WriteLine($"foreach (System.Collections.Generic.KeyValuePair<{keyTypeName}, {valueTypeName}> item in {obj.Name}){"{"}").Indent();

                    ctx.WriteLine(tagstr);
                    ctx.WriteLine(WriteString(mapMsgType.Fields[0].type, "item.Key"));
                    ctx.WriteLine(WriteString(mapMsgType.Fields[1].type, "item.Value"));

                    ctx.Outdent().WriteLine("}");
                    ctx.Outdent().WriteLine("}");
                }
                else
                {
                    ctx.WriteLine($"if({obj.Name}.Count > 0 ){"{"}").Indent();
                    ctx.WriteLine($"for (int i = 0; i < {obj.Name}.Count; i++){"{"}").Indent();

                    ctx.WriteLine(tagstr);
                    ctx.WriteLine(WriteString(obj.type, obj.Name + "[i]"));

                    ctx.Outdent().WriteLine("}");

                    ctx.Outdent().WriteLine("}");
                }
            }
            else
            {
                ctx.WriteLine(tagstr);
                ctx.WriteLine(WriteString(obj.type, obj.Name));
            }
        }
コード例 #24
0
ファイル: ILCodeGen.cs プロジェクト: uncaha/ProtoToCS
 protected void ReadCreatObjectStr(GeneratorContext ctx, string _typename, string _valuename)
 {
     ctx.WriteLine($"byte[] tchildbuffer = input.ReadBytes().ToByteArray();");
     ctx.WriteLine($"{_typename} {_valuename} = new {_typename}();");
     ctx.WriteLine($"{_valuename}.MergeFrom(tchildbuffer);");
 }
コード例 #25
0
ファイル: ILCodeGen.cs プロジェクト: uncaha/ProtoToCS
        protected void ReaderString(GeneratorContext ctx, FieldDescriptorProto obj)
        {
            bool isRepeated = obj.label == FieldDescriptorProto.Label.LabelRepeated;
            var  typeName   = GetTypeName(ctx, obj, out var dataFormat, out var isMap);

            string tfirstvalue = obj.Name;

            if (isRepeated)
            {
                tfirstvalue = $"{typeName} tvalue";
                ctx.WriteLine("{").Indent();
            }

            ReadBaseDataStr(ctx, obj.type, tfirstvalue, typeName);

            if (isRepeated)
            {
                var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(obj.TypeName) : null;
                if (mapMsgType != null)
                {
                    var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
                                                  out var keyDataFormat, out var _);
                    var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
                                                    out var valueDataFormat, out var _);

                    string tkey = "tkey";
                    if (FieldDescriptorProto.Type.TypeMessage == mapMsgType.Fields[0].type)
                    {
                        ReadCreatObjectStr(ctx, keyTypeName, tkey);
                    }
                    else
                    {
                        ReadBaseDataStr(ctx, mapMsgType.Fields[0].type, $"{keyTypeName} {tkey}", keyTypeName);
                    }

                    string tvalue = "tvalue";
                    if (FieldDescriptorProto.Type.TypeMessage == mapMsgType.Fields[1].type)
                    {
                        ReadCreatObjectStr(ctx, valueTypeName, tvalue);
                    }
                    else
                    {
                        ReadBaseDataStr(ctx, mapMsgType.Fields[1].type, $"{valueTypeName} {tvalue}", valueTypeName);
                    }

                    ctx.WriteLine($"{obj.Name}.Add({tkey}, {tvalue});");
                }
                else
                {
                    if (FieldDescriptorProto.Type.TypeMessage == obj.type)
                    {
                        ReadCreatObjectStr(ctx, typeName, "tobj");
                        ctx.WriteLine($"{obj.Name}.Add(tobj);");
                    }
                    else
                    {
                        ctx.WriteLine($"{obj.Name}.Add(tvalue);");
                    }
                }
                ctx.Outdent().WriteLine("}");
            }
            else
            {
                switch (obj.type)
                {
                case FieldDescriptorProto.Type.TypeMessage:
                    ctx.WriteLine("{").Indent();
                    ctx.WriteLine($"byte[] tchildbuffer = input.ReadBytes().ToByteArray();");
                    ctx.WriteLine($"{tfirstvalue}.MergeFrom(tchildbuffer);");
                    ctx.Outdent().WriteLine("}");
                    break;
                }
            }
        }
コード例 #26
0
ファイル: ILCodeGen.cs プロジェクト: uncaha/ProtoToCS
        protected void ReadBaseDataStr(GeneratorContext ctx, FieldDescriptorProto.Type _type, string _value, string _typename)
        {
            switch (_type)
            {
            case FieldDescriptorProto.Type.TypeSfixed32:
                ctx.WriteLine($"{_value} = input.ReadSFixed32();");
                break;

            case FieldDescriptorProto.Type.TypeFixed32:
                ctx.WriteLine($"{_value} = input.ReadFixed32();");
                break;

            case FieldDescriptorProto.Type.TypeSfixed64:
                ctx.WriteLine($"{_value} = input.ReadSFixed64();");
                break;

            case FieldDescriptorProto.Type.TypeFixed64:
                ctx.WriteLine($"{_value} = input.ReadFixed64();");
                break;

            case FieldDescriptorProto.Type.TypeInt32:
                ctx.WriteLine($"{_value} = input.ReadInt32();");
                break;

            case FieldDescriptorProto.Type.TypeInt64:
                ctx.WriteLine($"{_value} = input.ReadInt64();");
                break;

            case FieldDescriptorProto.Type.TypeSint32:
                ctx.WriteLine($"{_value} = input.ReadSInt32();");
                break;

            case FieldDescriptorProto.Type.TypeSint64:
                ctx.WriteLine($"{_value} = input.ReadSInt64();");
                break;

            case FieldDescriptorProto.Type.TypeUint32:
                ctx.WriteLine($"{_value} = input.ReadUInt32();");
                break;

            case FieldDescriptorProto.Type.TypeUint64:
                ctx.WriteLine($"{_value} = input.ReadUInt64();");
                break;


            case FieldDescriptorProto.Type.TypeFloat:
                ctx.WriteLine($"{_value} = input.ReadFloat();");
                break;

            case FieldDescriptorProto.Type.TypeDouble:
                ctx.WriteLine($"{_value} = input.ReadDouble();");
                break;

            case FieldDescriptorProto.Type.TypeBool:
                ctx.WriteLine($"{_value} = input.ReadBool();");
                break;

            case FieldDescriptorProto.Type.TypeEnum:
                ctx.WriteLine($"{_value} = ({_typename})input.ReadEnum();");
                break;

            case FieldDescriptorProto.Type.TypeString:
                ctx.WriteLine($"{_value} = input.ReadString();");
                break;

            case FieldDescriptorProto.Type.TypeBytes:
                ctx.WriteLine($"{_value} = input.ReadBytes().ToByteArray();");
                break;
            }
        }
コード例 #27
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");
        }
コード例 #28
0
 /// <inheritdoc/>
 protected override void WriteNamespaceHeader(GeneratorContext ctx, string @namespace)
 {
     ctx.WriteLine($"namespace {@namespace}");
     ctx.WriteLine("{").Indent().WriteLine();
 }
コード例 #29
0
        /// <summary>
        /// Write a field
        /// </summary>
        protected override void WriteField(GeneratorContext ctx, FieldDescriptorProto obj, ref object state, OneOfStub[] oneOfs)
        {
            var name = ctx.NameNormalizer.GetName(obj);
            var tw   = ctx.Write($@"[global::ProtoBuf.ProtoMember({obj.Number}");

            if (name != obj.Name)
            {
                tw.Write($@", Name = @""{obj.Name}""");
            }
            var options = obj.Options?.GetOptions();

            if (options?.AsReference == true)
            {
                tw.Write($@", AsReference = true");
            }
            if (options?.DynamicType == true)
            {
                tw.Write($@", DynamicType = true");
            }

            bool isOptional = obj.label == FieldDescriptorProto.Label.LabelOptional;
            bool isRepeated = obj.label == FieldDescriptorProto.Label.LabelRepeated;

            OneOfStub oneOf = obj.ShouldSerializeOneofIndex() ? oneOfs?[obj.OneofIndex] : null;

            if (oneOf != null && oneOf.CountTotal == 1)
            {
                oneOf = null; // not really a one-of, then!
            }
            bool explicitValues = isOptional && oneOf == null && ctx.Syntax == FileDescriptorProto.SyntaxProto2 &&
                                  obj.type != FieldDescriptorProto.Type.TypeMessage &&
                                  obj.type != FieldDescriptorProto.Type.TypeGroup;


            string defaultValue             = null;
            bool   suppressDefaultAttribute = !isOptional;

            if (isOptional || obj.type == FieldDescriptorProto.Type.TypeEnum)
            {
                defaultValue = obj.DefaultValue;

                if (obj.type == FieldDescriptorProto.Type.TypeString)
                {
                    defaultValue = string.IsNullOrEmpty(defaultValue) ? "\"\""
                        : ("@\"" + (defaultValue ?? "").Replace("\"", "\"\"") + "\"");
                }
                else if (obj.type == FieldDescriptorProto.Type.TypeDouble)
                {
                    switch (defaultValue)
                    {
                    case "inf": defaultValue = "double.PositiveInfinity"; break;

                    case "-inf": defaultValue = "double.NegativeInfinity"; break;

                    case "nan": defaultValue = "double.NaN"; break;
                    }
                }
                else if (obj.type == FieldDescriptorProto.Type.TypeFloat)
                {
                    switch (defaultValue)
                    {
                    case "inf": defaultValue = "float.PositiveInfinity"; break;

                    case "-inf": defaultValue = "float.NegativeInfinity"; break;

                    case "nan": defaultValue = "float.NaN"; break;
                    }
                }
                else if (obj.type == FieldDescriptorProto.Type.TypeEnum)
                {
                    var enumType = ctx.TryFind <EnumDescriptorProto>(obj.TypeName);
                    if (enumType != null)
                    {
                        EnumValueDescriptorProto found = null;
                        if (!string.IsNullOrEmpty(defaultValue))
                        {
                            found = enumType.Values.FirstOrDefault(x => x.Name == defaultValue);
                        }
                        else if (ctx.Syntax == FileDescriptorProto.SyntaxProto2)
                        {
                            // find the first one; if that is a zero, we don't need it after all
                            found = enumType.Values.FirstOrDefault();
                            if (found != null && found.Number == 0)
                            {
                                if (!isOptional)
                                {
                                    found = null;             // we don't need it after all
                                }
                            }
                        }
                        // for proto3 the default is 0, so no need to do anything - GetValueOrDefault() will do it all

                        if (found != null)
                        {
                            defaultValue = ctx.NameNormalizer.GetName(found);
                        }
                        if (!string.IsNullOrWhiteSpace(defaultValue))
                        {
                            defaultValue = ctx.NameNormalizer.GetName(enumType) + "." + defaultValue;
                        }
                    }
                }
            }
            var typeName = GetTypeName(ctx, obj, out var dataFormat, out var isMap);

            if (!string.IsNullOrWhiteSpace(dataFormat))
            {
                tw.Write($", DataFormat = global::ProtoBuf.DataFormat.{dataFormat}");
            }
            if (obj.IsPacked(ctx.Syntax))
            {
                tw.Write($", IsPacked = true");
            }
            if (obj.label == FieldDescriptorProto.Label.LabelRequired)
            {
                tw.Write($", IsRequired = true");
            }
            tw.WriteLine(")]");
            if (!isRepeated && !string.IsNullOrWhiteSpace(defaultValue) && !suppressDefaultAttribute)
            {
                ctx.WriteLine($"[global::System.ComponentModel.DefaultValue({defaultValue})]");
            }
            WriteOptions(ctx, obj.Options);
            if (isRepeated)
            {
                var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(obj.TypeName) : null;
                if (mapMsgType != null)
                {
                    var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
                                                  out var keyDataFormat, out var _);
                    var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
                                                    out var valueDataFormat, out var _);

                    bool first = true;
                    tw = ctx.Write($"[global::ProtoBuf.ProtoMap");
                    if (!string.IsNullOrWhiteSpace(keyDataFormat))
                    {
                        tw.Write($"{(first ? "(" : ", ")}KeyFormat = global::ProtoBuf.DataFormat.{keyDataFormat}");
                        first = false;
                    }
                    if (!string.IsNullOrWhiteSpace(valueDataFormat))
                    {
                        tw.Write($"{(first ? "(" : ", ")}ValueFormat = global::ProtoBuf.DataFormat.{valueDataFormat}");
                        first = false;
                    }
                    tw.WriteLine(first ? "]" : ")]");
                    ctx.WriteLine($"{GetAccess(GetAccess(obj))} global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}> {Escape(name)} {{ get; }} = new global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}>();");
                }
                else if (UseArray(obj))
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName}[] {Escape(name)} {{ get; set; }}");
                }
                else
                {
                    ctx.WriteLine($"{GetAccess(GetAccess(obj))} global::System.Collections.Generic.List<{typeName}> {Escape(name)} {{ get; }} = new global::System.Collections.Generic.List<{typeName}>();");
                }
            }
            else if (oneOf != null)
            {
                var defValue  = string.IsNullOrWhiteSpace(defaultValue) ? $"default({typeName})" : defaultValue;
                var fieldName = FieldPrefix + oneOf.OneOf.Name;
                var storage   = oneOf.GetStorage(obj.type, obj.TypeName);
                ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName} {Escape(name)}").WriteLine("{").Indent();

                switch (obj.type)
                {
                case FieldDescriptorProto.Type.TypeMessage:
                case FieldDescriptorProto.Type.TypeGroup:
                case FieldDescriptorProto.Type.TypeEnum:
                case FieldDescriptorProto.Type.TypeBytes:
                case FieldDescriptorProto.Type.TypeString:
                    ctx.WriteLine($"get {{ return {fieldName}.Is({obj.Number}) ? (({typeName}){fieldName}.{storage}) : {defValue}; }}");
                    break;

                default:
                    ctx.WriteLine($"get {{ return {fieldName}.Is({obj.Number}) ? {fieldName}.{storage} : {defValue}; }}");
                    break;
                }
                var unionType = oneOf.GetUnionType();
                ctx.WriteLine($"set {{ {fieldName} = new global::ProtoBuf.{unionType}({obj.Number}, value); }}")
                .Outdent().WriteLine("}")
                .WriteLine($"{GetAccess(GetAccess(obj))} bool ShouldSerialize{name}() => {fieldName}.Is({obj.Number});")
                .WriteLine($"{GetAccess(GetAccess(obj))} void Reset{name}() => global::ProtoBuf.{unionType}.Reset(ref {fieldName}, {obj.Number});");

                if (oneOf.IsFirst())
                {
                    ctx.WriteLine().WriteLine($"private global::ProtoBuf.{unionType} {fieldName};");
                }
            }
            else if (explicitValues)
            {
                string fieldName = FieldPrefix + name, fieldType;
                bool   isRef = false;
                switch (obj.type)
                {
                case FieldDescriptorProto.Type.TypeString:
                case FieldDescriptorProto.Type.TypeBytes:
                    fieldType = typeName;
                    isRef     = true;
                    break;

                default:
                    fieldType = typeName + "?";
                    break;
                }
                ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName} {Escape(name)}").WriteLine("{").Indent();
                tw = ctx.Write($"get {{ return {fieldName}");
                if (!string.IsNullOrWhiteSpace(defaultValue))
                {
                    tw.Write(" ?? ");
                    tw.Write(defaultValue);
                }
                else if (!isRef)
                {
                    tw.Write(".GetValueOrDefault()");
                }
                tw.WriteLine("; }");
                ctx.WriteLine($"set {{ {fieldName} = value; }}")
                .Outdent().WriteLine("}")
                .WriteLine($"{GetAccess(GetAccess(obj))} bool ShouldSerialize{name}() => {fieldName} != null;")
                .WriteLine($"{GetAccess(GetAccess(obj))} void Reset{name}() => {fieldName} = null;")
                .WriteLine($"private {fieldType} {fieldName};");
            }
            else
            {
                tw = ctx.Write($"{GetAccess(GetAccess(obj))} {typeName} {Escape(name)} {{ get; set; }}");
                if (!string.IsNullOrWhiteSpace(defaultValue))
                {
                    tw.Write($" = {defaultValue};");
                }
                tw.WriteLine();
            }
            ctx.WriteLine();
        }
コード例 #30
0
        /// <summary>
        /// Emit code representing a service method
        /// </summary>
        protected override void WriteServiceMethod(GeneratorContext ctx, MethodDescriptorProto method, ref object state)
        {
            var name = ctx.NameNormalizer.GetName(method);

            if (name != method.Name)
            {
                ctx.WriteLine($@"[global::System.ServiceModel.OperationContract(Name = @""{method.Name}"")]");
            }
            WriteOptions(ctx, method.Options);

            string returnType, inputType;

            if (method.ServerStreaming)
            {
                returnType = "global::System.Collection.Generics.IAsyncEnumerable<" + GetTypeName(ctx, method.OutputType) + ">";
            }
            else
            {
                if (method.OutputType == WellKnownTypeEmpty)
                {
                    returnType = "global::System.Threading.Tasks.ValueTask";
                }
                else
                {
                    returnType = "global::System.Threading.Tasks.ValueTask<" + GetTypeName(ctx, method.OutputType) + ">";
                }
            }
            if (method.ClientStreaming)
            {
                inputType = "global::System.Collection.Generics.IAsyncEnumerable<" + GetTypeName(ctx, method.InputType) + ">";
            }
            else
            {
                if (method.InputType == WellKnownTypeEmpty)
                {
                    inputType = null;
                }
                else
                {
                    inputType = GetTypeName(ctx, method.InputType);
                }
            }

            var tw = ctx.Write($"{returnType} {Escape(name)}Async(");

            if (inputType != null)
            {
                tw.Write(inputType);
                tw.Write(method.ClientStreaming ? " values, " : " value, ");
            }
            tw.Write("global::ProtoBuf.Grpc.CallContext context");
            if (ctx.Supports(CSharp4))
            {
                tw.Write(" = default");
                if (!ctx.Supports(CSharp7_1))
                {
                    tw.Write("(global::ProtoBuf.Grpc.CallContext)");
                }
            }
            tw.WriteLine(");");
        }