diff options
author | Jon Skeet <skeet@pobox.com> | 2008-10-22 13:30:34 +0100 |
---|---|---|
committer | Jon Skeet <skeet@pobox.com> | 2008-10-22 13:30:34 +0100 |
commit | 6803686bc06c4d96afd9bd2637f7b37a58596699 (patch) | |
tree | 4b21c563f4cd4e399fbc0b253bc2f15e822eae88 /src/ProtoGen/MessageGenerator.cs | |
parent | f0589506c96600dcd01319b9d1929d87505f3daa (diff) | |
download | protobuf-6803686bc06c4d96afd9bd2637f7b37a58596699.tar.gz protobuf-6803686bc06c4d96afd9bd2637f7b37a58596699.tar.bz2 protobuf-6803686bc06c4d96afd9bd2637f7b37a58596699.zip |
First cut at new layout
Diffstat (limited to 'src/ProtoGen/MessageGenerator.cs')
-rw-r--r-- | src/ProtoGen/MessageGenerator.cs | 453 |
1 files changed, 453 insertions, 0 deletions
diff --git a/src/ProtoGen/MessageGenerator.cs b/src/ProtoGen/MessageGenerator.cs new file mode 100644 index 00000000..95de1a38 --- /dev/null +++ b/src/ProtoGen/MessageGenerator.cs @@ -0,0 +1,453 @@ +using System.Collections; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.DescriptorProtos; +using System.Collections.Generic; + +using ExtensionRange = Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class MessageGenerator : SourceGeneratorBase<MessageDescriptor>, ISourceGenerator { + internal MessageGenerator(MessageDescriptor descriptor) : base(descriptor) { + } + + private string ClassName { + get { return Descriptor.Name; } + } + + private string FullClassName { + get { return DescriptorUtil.GetClassName(Descriptor); } + } + + /// <summary> + /// Get an identifier that uniquely identifies this type within the file. + /// This is used to declare static variables related to this type at the + /// outermost file scope. + /// </summary> + static string GetUniqueFileScopeIdentifier(IDescriptor descriptor) { + return "static_" + descriptor.FullName.Replace(".", "_"); + } + + internal void GenerateStaticVariables(TextGenerator writer) { + // Because descriptor.proto (Google.ProtocolBuffers.DescriptorProtos) is + // used in the construction of descriptors, we have a tricky bootstrapping + // problem. To help control static initialization order, we make sure all + // descriptors and other static data that depends on them are members of + // the proto-descriptor class. This way, they will be initialized in + // a deterministic order. + + string identifier = GetUniqueFileScopeIdentifier(Descriptor); + + // The descriptor for this type. + string access = Descriptor.File.Options.GetExtension(CSharpOptions.CSharpNestClasses) ? "private" : "internal"; + writer.WriteLine("{0} static readonly pbd::MessageDescriptor internal__{1}__Descriptor", access, identifier); + if (Descriptor.ContainingType == null) { + writer.WriteLine(" = Descriptor.MessageTypes[{0}];", Descriptor.Index); + } else { + writer.WriteLine(" = internal__{0}__Descriptor.NestedTypes[{1}];", GetUniqueFileScopeIdentifier(Descriptor.ContainingType), Descriptor.Index); + } + writer.WriteLine("{0} static pb::FieldAccess.FieldAccessorTable<{1}, {1}.Builder> internal__{2}__FieldAccessorTable", + access, FullClassName, identifier); + writer.WriteLine(" = new pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder>(internal__{1}__Descriptor,", + FullClassName, identifier); + writer.Print(" new string[] { "); + foreach (FieldDescriptor field in Descriptor.Fields) { + writer.Write("\"{0}\", ", Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field))); + } + writer.WriteLine("});"); + + // Generate static members for all nested types. + foreach (MessageDescriptor nestedMessage in Descriptor.NestedTypes) { + new MessageGenerator(nestedMessage).GenerateStaticVariables(writer); + } + } + + public void Generate(TextGenerator writer) { + writer.WriteLine("{0} sealed partial class {1} : pb::{2}Message<{1}, {1}.Builder> {{", + ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated"); + writer.Indent(); + // Must call BuildPartial() to make sure all lists are made read-only + writer.WriteLine("private static readonly {0} defaultInstance = new Builder().BuildPartial();", ClassName); + writer.WriteLine("public static {0} DefaultInstance {{", ClassName); + writer.WriteLine(" get { return defaultInstance; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName); + writer.WriteLine(" get { return defaultInstance; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("protected override {0} ThisMessage {{", ClassName); + writer.WriteLine(" get { return this; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public static pbd::MessageDescriptor Descriptor {"); + writer.WriteLine(" get {{ return {0}.internal__{1}__Descriptor; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File), + GetUniqueFileScopeIdentifier(Descriptor)); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("protected override pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder> InternalFieldAccessors {{", ClassName); + writer.WriteLine(" get {{ return {0}.internal__{1}__FieldAccessorTable; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File), + GetUniqueFileScopeIdentifier(Descriptor)); + writer.WriteLine("}"); + writer.WriteLine(); + + // Extensions don't need to go in an extra nested type + WriteChildren(writer, null, Descriptor.Extensions); + + if (Descriptor.EnumTypes.Count + Descriptor.NestedTypes.Count > 0) { + writer.WriteLine("#region Nested types"); + writer.WriteLine("public static class Types {"); + writer.Indent(); + WriteChildren(writer, null, Descriptor.EnumTypes); + WriteChildren(writer, null, Descriptor.NestedTypes); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine("#endregion"); + writer.WriteLine(); + } + + foreach(FieldDescriptor fieldDescriptor in Descriptor.Fields) { + // Rats: we lose the debug comment here :( + SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateMembers(writer); + writer.WriteLine(); + } + + if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) { + GenerateIsInitialized(writer); + GenerateMessageSerializationMethods(writer); + } + + GenerateParseFromMethods(writer); + GenerateBuilder(writer); + } + + private void GenerateMessageSerializationMethods(TextGenerator writer) { + List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields); + sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber)); + + List<ExtensionRange> sortedExtensions = new List<ExtensionRange>(Descriptor.Proto.ExtensionRangeList); + sortedExtensions.Sort((r1, r2) => (r1.Start.CompareTo(r2.Start))); + + writer.WriteLine("public override void WriteTo(pb::CodedOutputStream output) {"); + writer.Indent(); + if (Descriptor.Proto.ExtensionRangeList.Count > 0) { + writer.WriteLine("pb::ExtendableMessage<{0}, {0}.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);", + ClassName); + } + + // Merge the fields and the extension ranges, both sorted by field number. + for (int i = 0, j = 0; i < Descriptor.Fields.Count || j < sortedExtensions.Count; ) { + if (i == Descriptor.Fields.Count) { + GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]); + } else if (j == sortedExtensions.Count) { + GenerateSerializeOneField(writer, sortedFields[i++]); + } else if (sortedFields[i].FieldNumber < sortedExtensions[j].Start) { + GenerateSerializeOneField(writer, sortedFields[i++]); + } else { + GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]); + } + } + + if (Descriptor.Proto.Options.MessageSetWireFormat) { + writer.WriteLine("UnknownFields.WriteAsMessageSetTo(output);"); + } else { + writer.WriteLine("UnknownFields.WriteTo(output);"); + } + + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("private int memoizedSerializedSize = -1;"); + writer.WriteLine("public override int SerializedSize {"); + writer.Indent(); + writer.WriteLine("get {"); + writer.Indent(); + writer.WriteLine("int size = memoizedSerializedSize;"); + writer.WriteLine("if (size != -1) return size;"); + writer.WriteLine(); + writer.WriteLine("size = 0;"); + foreach (FieldDescriptor field in Descriptor.Fields) { + SourceGenerators.CreateFieldGenerator(field).GenerateSerializedSizeCode(writer); + } + if (Descriptor.Proto.ExtensionRangeCount > 0) { + writer.WriteLine("size += ExtensionsSerializedSize;"); + } + + if (Descriptor.Options.MessageSetWireFormat) { + writer.WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;"); + } else { + writer.WriteLine("size += UnknownFields.SerializedSize;"); + } + writer.WriteLine("memoizedSerializedSize = size;"); + writer.WriteLine("return size;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private static void GenerateSerializeOneField(TextGenerator writer, FieldDescriptor fieldDescriptor) { + SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateSerializationCode(writer); + } + + private static void GenerateSerializeOneExtensionRange(TextGenerator writer, ExtensionRange extensionRange) { + writer.WriteLine("extensionWriter.WriteUntil({0}, output);", extensionRange.End); + } + + private void GenerateParseFromMethods(TextGenerator writer) { + // Note: These are separate from GenerateMessageSerializationMethods() + // because they need to be generated even for messages that are optimized + // for code size. + + writer.WriteLine("public static {0} ParseFrom(pb::ByteString data) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(byte[] data) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + } + + /// <summary> + /// Returns whether or not the specified message type has any required fields. + /// If it doesn't, calls to check for initialization can be optimised. + /// TODO(jonskeet): Move this into MessageDescriptor? + /// </summary> + private static bool HasRequiredFields(MessageDescriptor descriptor, Dictionary<MessageDescriptor,object> alreadySeen) { + if (alreadySeen.ContainsKey(descriptor)) { + // The type is already in cache. This means that either: + // a. The type has no required fields. + // b. We are in the midst of checking if the type has required fields, + // somewhere up the stack. In this case, we know that if the type + // has any required fields, they'll be found when we return to it, + // and the whole call to HasRequiredFields() will return true. + // Therefore, we don't have to check if this type has required fields + // here. + return false; + } + alreadySeen[descriptor] = descriptor; // Value is irrelevant + + // If the type has extensions, an extension with message type could contain + // required fields, so we have to be conservative and assume such an + // extension exists. + if (descriptor.Extensions.Count > 0) { + return true; + } + + foreach (FieldDescriptor field in descriptor.Fields) { + if (field.IsRequired) { + return true; + } + // Message or group + if (field.MappedType == MappedType.Message) { + if (HasRequiredFields(field.MessageType, alreadySeen)) { + return true; + } + } + } + return false; + } + + private void GenerateBuilder(TextGenerator writer) { + writer.WriteLine("public static Builder CreateBuilder() { return new Builder(); }"); + writer.WriteLine("public override Builder CreateBuilderForType() { return new Builder(); }"); + writer.WriteLine("public static Builder CreateBuilder({0} prototype) {{", ClassName); + writer.WriteLine(" return (Builder) new Builder().MergeFrom(prototype);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("{0} sealed partial class Builder : pb::{2}Builder<{1}, Builder> {{", + ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated"); + writer.Indent(); + writer.WriteLine("protected override Builder ThisBuilder {"); + writer.WriteLine(" get { return this; }"); + writer.WriteLine("}"); + GenerateCommonBuilderMethods(writer); + if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) { + GenerateBuilderParsingMethods(writer); + } + foreach (FieldDescriptor field in Descriptor.Fields) { + writer.WriteLine(); + // No field comment :( + SourceGenerators.CreateFieldGenerator(field).GenerateBuilderMembers(writer); + } + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private void GenerateCommonBuilderMethods(TextGenerator writer) { + writer.WriteLine("{0} Builder() {{}}", ClassAccessLevel); + writer.WriteLine(); + writer.WriteLine("{0} result = new {0}();", ClassName); + writer.WriteLine(); + writer.WriteLine("protected override {0} MessageBeingBuilt {{", ClassName); + writer.WriteLine(" get { return result; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder Clear() {"); + writer.WriteLine(" result = new {0}();", ClassName); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder Clone() {"); + writer.WriteLine(" return new Builder().MergeFrom(result);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override pbd::MessageDescriptor DescriptorForType {"); + writer.WriteLine(" get {{ return {0}.Descriptor; }}", ClassName); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName); + writer.WriteLine(" get {{ return {0}.DefaultInstance; }}", ClassName); + writer.WriteLine("}"); + writer.WriteLine(); + + writer.WriteLine("public override {0} BuildPartial() {{", ClassName); + writer.Indent(); + foreach (FieldDescriptor field in Descriptor.Fields) { + SourceGenerators.CreateFieldGenerator(field).GenerateBuildingCode(writer); + } + writer.WriteLine("{0} returnMe = result;", ClassName); + writer.WriteLine("result = null;"); + writer.WriteLine("return returnMe;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + + if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) { + writer.WriteLine("public override Builder MergeFrom(pb::IMessage other) {"); + writer.WriteLine(" if (other is {0}) {{", ClassName); + writer.WriteLine(" return MergeFrom(({0}) other);", ClassName); + writer.WriteLine(" } else {"); + writer.WriteLine(" base.MergeFrom(other);"); + writer.WriteLine(" return this;"); + writer.WriteLine(" }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder MergeFrom({0} other) {{", ClassName); + // Optimization: If other is the default instance, we know none of its + // fields are set so we can skip the merge. + writer.Indent(); + writer.WriteLine("if (other == {0}.DefaultInstance) return this;", ClassName); + foreach (FieldDescriptor field in Descriptor.Fields) { + SourceGenerators.CreateFieldGenerator(field).GenerateMergingCode(writer); + } + writer.WriteLine("this.MergeUnknownFields(other.UnknownFields);"); + writer.WriteLine("return this;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + } + + private void GenerateBuilderParsingMethods(TextGenerator writer) { + List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields); + sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber)); + + writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input) {"); + writer.WriteLine(" return MergeFrom(input, pb::ExtensionRegistry.Empty);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {"); + writer.Indent(); + writer.WriteLine("pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);"); + writer.WriteLine("while (true) {"); + writer.Indent(); + writer.WriteLine("uint tag = input.ReadTag();"); + writer.WriteLine("switch (tag) {"); + writer.Indent(); + writer.WriteLine("case 0: {"); // 0 signals EOF / limit reached + writer.WriteLine(" this.UnknownFields = unknownFields.Build();"); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("default: {"); + writer.WriteLine(" if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {"); + writer.WriteLine(" this.UnknownFields = unknownFields.Build();"); + writer.WriteLine(" return this;"); // it's an endgroup tag + writer.WriteLine(" }"); + writer.WriteLine(" break;"); + writer.WriteLine("}"); + foreach (FieldDescriptor field in sortedFields) { + uint tag = WireFormat.MakeTag(field.FieldNumber, WireFormat.GetWireType(field.FieldType)); + writer.WriteLine("case {0}: {{", tag); + writer.Indent(); + SourceGenerators.CreateFieldGenerator(field).GenerateParsingCode(writer); + writer.WriteLine("break;"); + writer.Outdent(); + writer.WriteLine("}"); + } + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private void GenerateIsInitialized(TextGenerator writer) { + writer.WriteLine("public override bool IsInitialized {"); + writer.Indent(); + writer.WriteLine("get {"); + writer.Indent(); + + // Check that all required fields in this message are set. + // TODO(kenton): We can optimize this when we switch to putting all the + // "has" fields into a single bitfield. + foreach (FieldDescriptor field in Descriptor.Fields) { + if (field.IsRequired) { + writer.WriteLine("if (!has{0}) return false;", Helpers.UnderscoresToPascalCase(field.Name)); + } + } + + // Now check that all embedded messages are initialized. + foreach (FieldDescriptor field in Descriptor.Fields) { + if (field.FieldType != FieldType.Message || + !HasRequiredFields(field.MessageType, new Dictionary<MessageDescriptor, object>())) { + continue; + } + string propertyName = Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field)); + if (field.IsRepeated) { + writer.WriteLine("foreach ({0} element in {1}List) {{", DescriptorUtil.GetClassName(field.MessageType), propertyName); + writer.WriteLine(" if (!element.IsInitialized) return false;"); + writer.WriteLine("}"); + } else if (field.IsOptional) { + writer.WriteLine("if (Has{0}) {{", propertyName); + writer.WriteLine(" if (!{0}.IsInitialized) return false;", propertyName); + writer.WriteLine("}"); + } else { + writer.WriteLine("if (!{0}.IsInitialized) return false;", propertyName); + } + } + + if (Descriptor.Proto.ExtensionRangeCount > 0) { + writer.WriteLine("if (!ExtensionsAreInitialized) return false;"); + } + writer.WriteLine("return true;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + } +} |