diff options
author | ArnoldZokas <arnold.zokas@coderoom.net> | 2010-11-22 22:13:59 +0000 |
---|---|---|
committer | ArnoldZokas <arnold.zokas@coderoom.net> | 2010-11-22 22:13:59 +0000 |
commit | 64580d092f1d30328416b3836576fd25b82e5318 (patch) | |
tree | c08de5e5a1f1d7ecb1fc10b6edc26c6a7dafa243 /src/ProtoGen | |
parent | a695dfaa5a0dd60d818bd70f1798c651661cba43 (diff) | |
parent | 57599ef16daeda48381711dae1600cf0c467689d (diff) | |
download | protobuf-64580d092f1d30328416b3836576fd25b82e5318.tar.gz protobuf-64580d092f1d30328416b3836576fd25b82e5318.tar.bz2 protobuf-64580d092f1d30328416b3836576fd25b82e5318.zip |
Fixed merge conflicts
Diffstat (limited to 'src/ProtoGen')
-rw-r--r-- | src/ProtoGen/DescriptorUtil.cs | 19 | ||||
-rw-r--r-- | src/ProtoGen/Generator.cs | 57 | ||||
-rw-r--r-- | src/ProtoGen/GeneratorOptions.cs | 181 | ||||
-rw-r--r-- | src/ProtoGen/Program.cs | 21 | ||||
-rw-r--r-- | src/ProtoGen/ProgramPreprocess.cs | 153 | ||||
-rw-r--r-- | src/ProtoGen/ProtoGen.csproj | 2 | ||||
-rw-r--r-- | src/ProtoGen/ServiceGenerator.cs | 2 | ||||
-rw-r--r-- | src/ProtoGen/UmbrellaClassGenerator.cs | 15 |
8 files changed, 413 insertions, 37 deletions
diff --git a/src/ProtoGen/DescriptorUtil.cs b/src/ProtoGen/DescriptorUtil.cs index 14d28bb8..af5a2f9a 100644 --- a/src/ProtoGen/DescriptorUtil.cs +++ b/src/ProtoGen/DescriptorUtil.cs @@ -45,11 +45,26 @@ namespace Google.ProtocolBuffers.ProtoGen { internal static string GetFullUmbrellaClassName(IDescriptor descriptor) { CSharpFileOptions options = descriptor.File.CSharpOptions; string result = options.Namespace; - if (result != "") result += '.'; - result += options.UmbrellaClassname; + if (result != "") { + result += '.'; + } + result += GetQualifiedUmbrellaClassName(options); return "global::" + result; } + /// <summary> + /// Evaluates the options and returns the qualified name of the umbrella class + /// relative to the descriptor type's namespace. Basically concatenates the + /// UmbrellaNamespace + UmbrellaClassname fields. + /// </summary> + internal static string GetQualifiedUmbrellaClassName(CSharpFileOptions options) { + string fullName = options.UmbrellaClassname; + if (!options.NestClasses && options.UmbrellaNamespace != "") { + fullName = String.Format("{0}.{1}", options.UmbrellaNamespace, options.UmbrellaClassname); + } + return fullName; + } + internal static string GetMappedTypeName(MappedType type) { switch(type) { case MappedType.Int32: return "int"; diff --git a/src/ProtoGen/Generator.cs b/src/ProtoGen/Generator.cs index 7e48ad67..f588c141 100644 --- a/src/ProtoGen/Generator.cs +++ b/src/ProtoGen/Generator.cs @@ -60,19 +60,30 @@ namespace Google.ProtocolBuffers.ProtoGen { } public void Generate() { + + List<FileDescriptorSet> descriptorProtos = new List<FileDescriptorSet>(); foreach (string inputFile in options.InputFiles) { - FileDescriptorSet descriptorProtos; ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); extensionRegistry.Add(CSharpOptions.CSharpFileOptions); extensionRegistry.Add(CSharpOptions.CSharpFieldOptions); using (Stream inputStream = File.OpenRead(inputFile)) { - descriptorProtos = FileDescriptorSet.ParseFrom(inputStream, extensionRegistry); + descriptorProtos.Add(FileDescriptorSet.ParseFrom(inputStream, extensionRegistry)); } - IList<FileDescriptor> descriptors = ConvertDescriptors(descriptorProtos); + } + + IList<FileDescriptor> descriptors = ConvertDescriptors(options.FileOptions, descriptorProtos.ToArray()); + + // Combine with options from command line + foreach (FileDescriptor descriptor in descriptors) { + descriptor.ConfigureWithDefaultOptions(options.FileOptions); + } - foreach (FileDescriptor descriptor in descriptors) { - Generate(descriptor); + foreach (FileDescriptor descriptor in descriptors) { + // Optionally exclude descriptors in google.protobuf + if (descriptor.CSharpOptions.IgnoreGoogleProtobuf && descriptor.Package == "google.protobuf") { + continue; } + Generate(descriptor); } } @@ -90,8 +101,10 @@ namespace Google.ProtocolBuffers.ProtoGen { private string GetOutputFile(FileDescriptor descriptor) { CSharpFileOptions fileOptions = descriptor.CSharpOptions; - string filename = descriptor.CSharpOptions.UmbrellaClassname + ".cs"; - string outputDirectory = options.OutputDirectory; + + string filename = descriptor.CSharpOptions.UmbrellaClassname + descriptor.CSharpOptions.FileExtension; + + string outputDirectory = descriptor.CSharpOptions.OutputDirectory; if (fileOptions.ExpandNamespaceDirectories) { string package = fileOptions.Namespace; if (!string.IsNullOrEmpty(package)) { @@ -99,9 +112,11 @@ namespace Google.ProtocolBuffers.ProtoGen { foreach (string bit in bits) { outputDirectory = Path.Combine(outputDirectory, bit); } - Directory.CreateDirectory(outputDirectory); } } + + // As the directory can be explicitly specified in options, we need to make sure it exists + Directory.CreateDirectory(outputDirectory); return Path.Combine(outputDirectory, filename); } @@ -111,10 +126,13 @@ namespace Google.ProtocolBuffers.ProtoGen { /// Note: this method is internal rather than private to allow testing. /// </summary> /// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception> - internal static IList<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos) { + internal static IList<FileDescriptor> ConvertDescriptors(CSharpFileOptions options, params FileDescriptorSet[] descriptorProtos) { // Simple strategy: Keep going through the list of protos to convert, only doing ones where // we've already converted all the dependencies, until we get to a stalemate - IList<FileDescriptorProto> fileList = descriptorProtos.FileList; + List<FileDescriptorProto> fileList = new List<FileDescriptorProto>(); + foreach (FileDescriptorSet set in descriptorProtos) + fileList.AddRange(set.FileList); + FileDescriptor[] converted = new FileDescriptor[fileList.Count]; Dictionary<string, FileDescriptor> convertedMap = new Dictionary<string, FileDescriptor>(); @@ -131,9 +149,28 @@ namespace Google.ProtocolBuffers.ProtoGen { } FileDescriptorProto candidate = fileList[i]; FileDescriptor[] dependencies = new FileDescriptor[candidate.DependencyList.Count]; + + + CSharpFileOptions.Builder builder = options.ToBuilder(); + if (candidate.Options.HasExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions)) { + builder.MergeFrom(candidate.Options.GetExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions)); + } + CSharpFileOptions localOptions = builder.Build(); + bool foundAllDependencies = true; for (int j = 0; j < dependencies.Length; j++) { if (!convertedMap.TryGetValue(candidate.DependencyList[j], out dependencies[j])) { + // We can auto-magically resolve these since we already have their description + // This way if the file is only referencing options it does not need to be built with the + // --include_imports definition. + if (localOptions.IgnoreGoogleProtobuf && (candidate.DependencyList[j] == "google/protobuf/csharp_options.proto")) { + dependencies[j] = CSharpOptions.Descriptor; + continue; + } + if (localOptions.IgnoreGoogleProtobuf && (candidate.DependencyList[j] == "google/protobuf/descriptor.proto")) { + dependencies[j] = DescriptorProtoFile.Descriptor; + continue; + } foundAllDependencies = false; break; } diff --git a/src/ProtoGen/GeneratorOptions.cs b/src/ProtoGen/GeneratorOptions.cs index 1f3d8f2b..8781c5ec 100644 --- a/src/ProtoGen/GeneratorOptions.cs +++ b/src/ProtoGen/GeneratorOptions.cs @@ -1,4 +1,5 @@ #region Copyright notice and license + // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // http://github.com/jskeet/dotnet-protobufs/ @@ -30,13 +31,17 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #endregion +using System; using System.Collections.Generic; using System.IO; +using System.Text.RegularExpressions; +using Google.ProtocolBuffers.DescriptorProtos; +using Google.ProtocolBuffers.Descriptors; namespace Google.ProtocolBuffers.ProtoGen { - /// <summary> /// All the configuration required for the generator - where to generate /// output files, the location of input files etc. While this isn't immutable @@ -44,8 +49,6 @@ namespace Google.ProtocolBuffers.ProtoGen { /// the generator. /// </summary> public sealed class GeneratorOptions { - - public string OutputDirectory { get; set; } public IList<string> InputFiles { get; set; } /// <summary> @@ -58,19 +61,23 @@ namespace Google.ProtocolBuffers.ProtoGen { public bool TryValidate(out IList<string> reasons) { List<string> tmpReasons = new List<string>(); + ParseArguments(tmpReasons); + // Output directory validation - if (string.IsNullOrEmpty(OutputDirectory)) { + if (string.IsNullOrEmpty(FileOptions.OutputDirectory)) { tmpReasons.Add("No output directory specified"); - } else { - if (!Directory.Exists(OutputDirectory)) { - tmpReasons.Add("Specified output directory (" + OutputDirectory + " doesn't exist."); + } + else { + if (!Directory.Exists(FileOptions.OutputDirectory)) { + tmpReasons.Add("Specified output directory (" + FileOptions.OutputDirectory + " doesn't exist."); } } // Input file validation (just in terms of presence) if (InputFiles == null || InputFiles.Count == 0) { tmpReasons.Add("No input files specified"); - } else { + } + else { foreach (string input in InputFiles) { FileInfo fi = new FileInfo(input); if (!fi.Exists) { @@ -99,5 +106,161 @@ namespace Google.ProtocolBuffers.ProtoGen { throw new InvalidOptionsException(reasons); } } + + // Raw arguments, used to provide defaults for proto file options + public IList<string> Arguments { get; set; } + + [Obsolete("Please use GeneratorOptions.FileOptions.OutputDirectory instead")] + public string OutputDirectory { + get { return FileOptions.OutputDirectory; } + set { + CSharpFileOptions.Builder bld = FileOptions.ToBuilder(); + bld.OutputDirectory = value; + FileOptions = bld.Build(); + } + } + + private static readonly Regex ArgMatch = new Regex(@"^[-/](?<name>[\w_]+?)[:=](?<value>.*)$"); + private CSharpFileOptions fileOptions; + + public CSharpFileOptions FileOptions { + get { return fileOptions ?? (fileOptions = CSharpFileOptions.DefaultInstance); } + set { fileOptions = value; } + } + + private void ParseArguments(IList<string> tmpReasons) { + bool doHelp = Arguments.Count == 0; + + InputFiles = new List<string>(); + CSharpFileOptions.Builder builder = FileOptions.ToBuilder(); + Dictionary<string, FieldDescriptor> fields = + new Dictionary<string, FieldDescriptor>(StringComparer.OrdinalIgnoreCase); + foreach (FieldDescriptor fld in builder.DescriptorForType.Fields) { + fields.Add(fld.Name, fld); + } + + foreach (string argument in Arguments) { + if (StringComparer.OrdinalIgnoreCase.Equals("-help", argument) || + StringComparer.OrdinalIgnoreCase.Equals("/help", argument) || + StringComparer.OrdinalIgnoreCase.Equals("-?", argument) || + StringComparer.OrdinalIgnoreCase.Equals("/?", argument)) { + doHelp = true; + break; + } + + Match m = ArgMatch.Match(argument); + if (m.Success) { + FieldDescriptor fld; + string name = m.Groups["name"].Value; + string value = m.Groups["value"].Value; + + if (fields.TryGetValue(name, out fld)) { + object obj; + if (TryCoerceType(value, fld, out obj, tmpReasons)) { + builder[fld] = obj; + } + } + else if (!File.Exists(argument)) { + doHelp = true; + tmpReasons.Add("Unknown argument '" + name + "'."); + } + else { + InputFiles.Add(argument); + } + } + else { + InputFiles.Add(argument); + } + } + + if (doHelp || InputFiles.Count == 0) { + tmpReasons.Add("Arguments:"); + foreach (KeyValuePair<string, FieldDescriptor> field in fields) { + tmpReasons.Add(String.Format("-{0}=[{1}]", field.Key, field.Value.FieldType)); + } + tmpReasons.Add("followed by one or more file paths."); + } + else { + FileOptions = builder.Build(); + } + } + + private static bool TryCoerceType(string text, FieldDescriptor field, out object value, IList<string> tmpReasons) { + value = null; + + switch (field.FieldType) { + case FieldType.Int32: + case FieldType.SInt32: + case FieldType.SFixed32: + value = Int32.Parse(text); + break; + + case FieldType.Int64: + case FieldType.SInt64: + case FieldType.SFixed64: + value = Int64.Parse(text); + break; + + case FieldType.UInt32: + case FieldType.Fixed32: + value = UInt32.Parse(text); + break; + + case FieldType.UInt64: + case FieldType.Fixed64: + value = UInt64.Parse(text); + break; + + case FieldType.Float: + value = float.Parse(text); + break; + + case FieldType.Double: + value = Double.Parse(text); + break; + + case FieldType.Bool: + value = Boolean.Parse(text); + break; + + case FieldType.String: + value = text; + break; + + case FieldType.Enum: { + EnumDescriptor enumType = field.EnumType; + + int number; + if (int.TryParse(text, out number)) { + value = enumType.FindValueByNumber(number); + if (value == null) { + tmpReasons.Add( + "Enum type \"" + enumType.FullName + + "\" has no value with number " + number + "."); + return false; + } + } + else { + value = enumType.FindValueByName(text); + if (value == null) { + tmpReasons.Add( + "Enum type \"" + enumType.FullName + + "\" has no value named \"" + text + "\"."); + return false; + } + } + + break; + } + + case FieldType.Bytes: + case FieldType.Message: + case FieldType.Group: + tmpReasons.Add("Unhandled field type " + field.FieldType.ToString() + "."); + return false; + } + + return true; + } } -} +}
\ No newline at end of file diff --git a/src/ProtoGen/Program.cs b/src/ProtoGen/Program.cs index f9f80f25..e8c486cf 100644 --- a/src/ProtoGen/Program.cs +++ b/src/ProtoGen/Program.cs @@ -1,4 +1,5 @@ #region Copyright notice and license + // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // http://github.com/jskeet/dotnet-protobufs/ @@ -30,6 +31,7 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + #endregion using System; @@ -40,12 +42,12 @@ namespace Google.ProtocolBuffers.ProtoGen { /// <summary> /// Entry point for the Protocol Buffers generator. /// </summary> - class Program { - static int Main(string[] args) { + internal class Program { + internal static int Main(string[] args) { try { // Hack to make sure everything's initialized DescriptorProtoFile.Descriptor.ToString(); - GeneratorOptions options = ParseCommandLineArguments(args); + GeneratorOptions options = new GeneratorOptions {Arguments = args}; IList<string> validationFailures; if (!options.TryValidate(out validationFailures)) { @@ -58,22 +60,13 @@ namespace Google.ProtocolBuffers.ProtoGen { Generator generator = Generator.CreateGenerator(options); generator.Generate(); return 0; - } catch (Exception e) { + } + catch (Exception e) { Console.Error.WriteLine("Error: {0}", e.Message); Console.Error.WriteLine(); Console.Error.WriteLine("Detailed exception information: {0}", e); return 1; } } - - private static GeneratorOptions ParseCommandLineArguments(string[] args) { - GeneratorOptions options = new GeneratorOptions(); - //string baseDir = "c:\\Users\\Jon\\Documents\\Visual Studio 2008\\Projects\\ProtocolBuffers"; - //options.OutputDirectory = baseDir + "\\tmp"; - //options.InputFiles = new[] { baseDir + "\\protos\\nwind-solo.protobin" }; - options.OutputDirectory = "."; - options.InputFiles = args; - return options; - } } }
\ No newline at end of file diff --git a/src/ProtoGen/ProgramPreprocess.cs b/src/ProtoGen/ProgramPreprocess.cs new file mode 100644 index 00000000..f6032a54 --- /dev/null +++ b/src/ProtoGen/ProgramPreprocess.cs @@ -0,0 +1,153 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Preprocesses any input files with an extension of '.proto' by running protoc.exe. If arguments + /// are supplied with '--' prefix they are provided to protoc.exe, otherwise they are assumed to + /// be used for ProtoGen.exe which is run on the resulting output proto buffer. If the option + /// --descriptor_set_out= is specified the proto buffer file is kept, otherwise it will be removed + /// after code generation. + /// </summary> + internal class ProgramPreprocess { + private static int Main(string[] args) { + try { + return Environment.ExitCode = Run(args); + } + catch (Exception ex) { + Console.Error.WriteLine(ex); + return Environment.ExitCode = 2; + } + } + + internal static int Run(params string[] args) { + bool deleteFile = false; + string tempFile = null; + int result; + bool doHelp = args.Length == 0; + try { + List<string> protocArgs = new List<string>(); + List<string> protoGenArgs = new List<string>(); + + foreach (string arg in args) { + doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "/?"); + doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "/help"); + doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "-?"); + doHelp |= StringComparer.OrdinalIgnoreCase.Equals(arg, "-help"); + + if (arg.StartsWith("--descriptor_set_out=")) { + tempFile = arg.Substring("--descriptor_set_out=".Length); + protoGenArgs.Add(tempFile); + } + } + + if (doHelp) { + Console.WriteLine(); + Console.WriteLine("PROTOC.exe: Use any of the following options that begin with '--':"); + Console.WriteLine(); + try { + RunProtoc("--help"); + } + catch (Exception ex) { + Console.Error.WriteLine(ex.Message); + } + Console.WriteLine(); + Console.WriteLine(); + Console.WriteLine("PRTOGEN.exe: The following options are used to specify defaults for code generation."); + Console.WriteLine(); + Program.Main(new string[0]); + return 0; + } + + foreach (string arg in args) { + if (arg.StartsWith("--")) { + protocArgs.Add(arg); + } + else if (File.Exists(arg) && StringComparer.OrdinalIgnoreCase.Equals(".proto", Path.GetExtension(arg))) { + if (tempFile == null) { + deleteFile = true; + tempFile = Path.GetTempFileName(); + protocArgs.Add(String.Format("--descriptor_set_out={0}", tempFile)); + protoGenArgs.Add(tempFile); + } + protocArgs.Add(arg); + } + else { + protoGenArgs.Add(arg); + } + } + + if (tempFile != null) { + result = RunProtoc(protocArgs.ToArray()); + if (result != 0) { + return result; + } + } + + result = Program.Main(protoGenArgs.ToArray()); + } + finally { + if (deleteFile && tempFile != null && File.Exists(tempFile)) { + File.Delete(tempFile); + } + } + return result; + } + + private static int RunProtoc(params string[] args) { + const string protoc = "protoc.exe"; + string exePath = protoc; + + // Why oh why is this not in System.IO.Path or Environment...? + List<string> searchPath = new List<string>(); + searchPath.Add(Environment.CurrentDirectory); + searchPath.Add(AppDomain.CurrentDomain.BaseDirectory); + searchPath.AddRange((Environment.GetEnvironmentVariable("PATH") ?? String.Empty).Split(Path.PathSeparator)); + + foreach (string path in searchPath) { + if (File.Exists(exePath = Path.Combine(path, protoc))) { + break; + } + } + + if (!File.Exists(exePath)) { + throw new FileNotFoundException("Unable to locate " + protoc + " make sure it is in the PATH, cwd, or exe dir."); + } + + for (int i = 0; i < args.Length; i++) { + if (args[i].IndexOf(' ') > 0 && args[i][0] != '"') { + args[i] = '"' + args[i] + '"'; + } + } + + ProcessStartInfo psi = new ProcessStartInfo(exePath); + psi.Arguments = String.Join(" ", args); + psi.RedirectStandardError = true; + psi.RedirectStandardInput = false; + psi.RedirectStandardOutput = true; + psi.ErrorDialog = false; + psi.CreateNoWindow = true; + psi.UseShellExecute = false; + psi.WorkingDirectory = Environment.CurrentDirectory; + + Process process = Process.Start(psi); + if (process == null) { + return 1; + } + + process.WaitForExit(); + + string tmp = process.StandardOutput.ReadToEnd(); + if (tmp.Trim().Length > 0) { + Console.Out.WriteLine(tmp); + } + tmp = process.StandardError.ReadToEnd(); + if (tmp.Trim().Length > 0) { + Console.Error.WriteLine(tmp); + } + return process.ExitCode; + } + } +} diff --git a/src/ProtoGen/ProtoGen.csproj b/src/ProtoGen/ProtoGen.csproj index 100db99f..228d6932 100644 --- a/src/ProtoGen/ProtoGen.csproj +++ b/src/ProtoGen/ProtoGen.csproj @@ -34,6 +34,7 @@ <IsWebBootstrapper>false</IsWebBootstrapper> <UseApplicationTrust>false</UseApplicationTrust> <BootstrapperEnabled>true</BootstrapperEnabled> + <StartupObject>Google.ProtocolBuffers.ProtoGen.ProgramPreprocess</StartupObject> </PropertyGroup> <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> <DebugSymbols>true</DebugSymbols> @@ -79,6 +80,7 @@ <Compile Include="MessageFieldGenerator.cs" /> <Compile Include="MessageGenerator.cs" /> <Compile Include="PrimitiveFieldGenerator.cs" /> + <Compile Include="ProgramPreprocess.cs" /> <Compile Include="RepeatedEnumFieldGenerator.cs" /> <Compile Include="RepeatedMessageFieldGenerator.cs" /> <Compile Include="RepeatedPrimitiveFieldGenerator.cs" /> diff --git a/src/ProtoGen/ServiceGenerator.cs b/src/ProtoGen/ServiceGenerator.cs index a7a4471e..03d2f120 100644 --- a/src/ProtoGen/ServiceGenerator.cs +++ b/src/ProtoGen/ServiceGenerator.cs @@ -61,7 +61,7 @@ namespace Google.ProtocolBuffers.ProtoGen { writer.WriteLine(); writer.WriteLine("{0} static pbd::ServiceDescriptor Descriptor {{", ClassAccessLevel); writer.WriteLine(" get {{ return {0}.Descriptor.Services[{1}]; }}", - Descriptor.File.CSharpOptions.UmbrellaClassname, Descriptor.Index); + DescriptorUtil.GetQualifiedUmbrellaClassName(Descriptor.File.CSharpOptions), Descriptor.Index); writer.WriteLine("}"); writer.WriteLine("{0} pbd::ServiceDescriptor DescriptorForType {{", ClassAccessLevel); writer.WriteLine(" get { return Descriptor; }"); diff --git a/src/ProtoGen/UmbrellaClassGenerator.cs b/src/ProtoGen/UmbrellaClassGenerator.cs index 9dcbcab9..cdc275c6 100644 --- a/src/ProtoGen/UmbrellaClassGenerator.cs +++ b/src/ProtoGen/UmbrellaClassGenerator.cs @@ -92,6 +92,12 @@ namespace Google.ProtocolBuffers.ProtoGen { if (!Descriptor.CSharpOptions.NestClasses) { writer.Outdent(); writer.WriteLine("}"); + + // Close the namespace around the umbrella class if defined + if (!Descriptor.CSharpOptions.NestClasses && Descriptor.CSharpOptions.UmbrellaNamespace != "") { + writer.Outdent(); + writer.WriteLine("}"); + } } WriteChildren(writer, "Enums", Descriptor.EnumTypes); WriteChildren(writer, "Messages", Descriptor.MessageTypes); @@ -115,7 +121,14 @@ namespace Google.ProtocolBuffers.ProtoGen { writer.WriteLine("namespace {0} {{", Descriptor.CSharpOptions.Namespace); writer.Indent(); writer.WriteLine(); - } + } + // Add the namespace around the umbrella class if defined + if(!Descriptor.CSharpOptions.NestClasses && Descriptor.CSharpOptions.UmbrellaNamespace != "") { + writer.WriteLine("namespace {0} {{", Descriptor.CSharpOptions.UmbrellaNamespace); + writer.Indent(); + writer.WriteLine(); + } + if (Descriptor.CSharpOptions.CodeContracts) { writer.WriteLine("[global::System.Diagnostics.Contracts.ContractVerificationAttribute(false)]"); } |