Context Navigation

source: tags/3.3.11/HeuristicLab.ExtLibs/HeuristicLab.ProtobufCS/2.4.1/ProtobufCS/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs @ 13398

Visit:

Last change on this file since 13398 was 8295, checked in by abeham, 12 years ago

Removed protocol buffers 0.9.1
Added protocol buffers 2.4.1
Updated proto processing command

File size: 73.3 KB

Line
1	// Generated by ProtoGen, Version=2.3.0.277, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48. DO NOT EDIT!
2	#pragma warning disable 1591, 0612
3	#region Designer generated code
4
5	using pb = global::Google.ProtocolBuffers;
6	using pbc = global::Google.ProtocolBuffers.Collections;
7	using pbd = global::Google.ProtocolBuffers.Descriptors;
8	using scg = global::System.Collections.Generic;
9	namespace Google.ProtocolBuffers.DescriptorProtos {
10
11	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
12	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
13	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
14	public static partial class CSharpOptions {
15
16	#region Extension registration
17	public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
18	registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFileOptions);
19	registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFieldOptions);
20	registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpServiceOptions);
21	registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpMethodOptions);
22	}
23	#endregion
24	#region Extensions
25	public const int CSharpFileOptionsFieldNumber = 1000;
26	public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions> CSharpFileOptions;
27	public const int CSharpFieldOptionsFieldNumber = 1000;
28	public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions> CSharpFieldOptions;
29	public const int CsharpServiceOptionsFieldNumber = 1000;
30	public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions> CsharpServiceOptions;
31	public const int CsharpMethodOptionsFieldNumber = 1000;
32	public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions> CsharpMethodOptions;
33	#endregion
34
35	#region Static variables
36	internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpFileOptions__Descriptor;
37	internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder> internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable;
38	internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpFieldOptions__Descriptor;
39	internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder> internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable;
40	internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpServiceOptions__Descriptor;
41	internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Builder> internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable;
42	internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpMethodOptions__Descriptor;
43	internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Builder> internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable;
44	#endregion
45	#region Descriptor
46	public static pbd::FileDescriptor Descriptor {
47	get { return descriptor; }
48	}
49	private static pbd::FileDescriptor descriptor;
50
51	static CSharpOptions() {
52	byte[] descriptorData = global::System.Convert.FromBase64String(
53	"CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds" +
54	"ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG8i" +
55	"/AMKEUNTaGFycEZpbGVPcHRpb25zEhEKCW5hbWVzcGFjZRgBIAEoCRIaChJ1" +
56	"bWJyZWxsYV9jbGFzc25hbWUYAiABKAkSHAoOcHVibGljX2NsYXNzZXMYAyAB" +
57	"KAg6BHRydWUSFgoObXVsdGlwbGVfZmlsZXMYBCABKAgSFAoMbmVzdF9jbGFz" +
58	"c2VzGAUgASgIEhYKDmNvZGVfY29udHJhY3RzGAYgASgIEiQKHGV4cGFuZF9u" +
59	"YW1lc3BhY2VfZGlyZWN0b3JpZXMYByABKAgSHAoOY2xzX2NvbXBsaWFuY2UY" +
60	"CCABKAg6BHRydWUSHwoQYWRkX3NlcmlhbGl6YWJsZRgJIAEoCDoFZmFsc2US" +
61	"IwoVZ2VuZXJhdGVfcHJpdmF0ZV9jdG9yGAogASgIOgR0cnVlEhwKDmZpbGVf" +
62	"ZXh0ZW5zaW9uGN0BIAEoCToDLmNzEhsKEnVtYnJlbGxhX25hbWVzcGFjZRje" +
63	"ASABKAkSHAoQb3V0cHV0X2RpcmVjdG9yeRjfASABKAk6AS4SJgoWaWdub3Jl" +
64	"X2dvb2dsZV9wcm90b2J1ZhjgASABKAg6BWZhbHNlEkkKFnNlcnZpY2VfZ2Vu" +
65	"ZXJhdG9yX3R5cGUY4QEgASgOMiIuZ29vZ2xlLnByb3RvYnVmLkNTaGFycFNl" +
66	"cnZpY2VUeXBlOgROT05FIisKEkNTaGFycEZpZWxkT3B0aW9ucxIVCg1wcm9w" +
67	"ZXJ0eV9uYW1lGAEgASgJIiwKFENTaGFycFNlcnZpY2VPcHRpb25zEhQKDGlu" +
68	"dGVyZmFjZV9pZBgBIAEoCSIqChNDU2hhcnBNZXRob2RPcHRpb25zEhMKC2Rp" +
69	"c3BhdGNoX2lkGAEgASgFKksKEUNTaGFycFNlcnZpY2VUeXBlEggKBE5PTkUQ" +
70	"ABILCgdHRU5FUklDEAESDQoJSU5URVJGQUNFEAISEAoMSVJQQ0RJU1BBVENI" +
71	"EAM6XgoTY3NoYXJwX2ZpbGVfb3B0aW9ucxIcLmdvb2dsZS5wcm90b2J1Zi5G" +
72	"aWxlT3B0aW9ucxjoByABKAsyIi5nb29nbGUucHJvdG9idWYuQ1NoYXJwRmls" +
73	"ZU9wdGlvbnM6YQoUY3NoYXJwX2ZpZWxkX29wdGlvbnMSHS5nb29nbGUucHJv" +
74	"dG9idWYuRmllbGRPcHRpb25zGOgHIAEoCzIjLmdvb2dsZS5wcm90b2J1Zi5D" +
75	"U2hhcnBGaWVsZE9wdGlvbnM6ZwoWY3NoYXJwX3NlcnZpY2Vfb3B0aW9ucxIf" +
76	"Lmdvb2dsZS5wcm90b2J1Zi5TZXJ2aWNlT3B0aW9ucxjoByABKAsyJS5nb29n" +
77	"bGUucHJvdG9idWYuQ1NoYXJwU2VydmljZU9wdGlvbnM6ZAoVY3NoYXJwX21l" +
78	"dGhvZF9vcHRpb25zEh4uZ29vZ2xlLnByb3RvYnVmLk1ldGhvZE9wdGlvbnMY" +
79	"6AcgASgLMiQuZ29vZ2xlLnByb3RvYnVmLkNTaGFycE1ldGhvZE9wdGlvbnM=");
80	pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
81	descriptor = root;
82	internal__static_google_protobuf_CSharpFileOptions__Descriptor = Descriptor.MessageTypes[0];
83	internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable =
84	new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder>(internal__static_google_protobuf_CSharpFileOptions__Descriptor,
85	new string[] { "Namespace", "UmbrellaClassname", "PublicClasses", "MultipleFiles", "NestClasses", "CodeContracts", "ExpandNamespaceDirectories", "ClsCompliance", "AddSerializable", "GeneratePrivateCtor", "FileExtension", "UmbrellaNamespace", "OutputDirectory", "IgnoreGoogleProtobuf", "ServiceGeneratorType", });
86	internal__static_google_protobuf_CSharpFieldOptions__Descriptor = Descriptor.MessageTypes[1];
87	internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable =
88	new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder>(internal__static_google_protobuf_CSharpFieldOptions__Descriptor,
89	new string[] { "PropertyName", });
90	internal__static_google_protobuf_CSharpServiceOptions__Descriptor = Descriptor.MessageTypes[2];
91	internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable =
92	new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Builder>(internal__static_google_protobuf_CSharpServiceOptions__Descriptor,
93	new string[] { "InterfaceId", });
94	internal__static_google_protobuf_CSharpMethodOptions__Descriptor = Descriptor.MessageTypes[3];
95	internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable =
96	new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Builder>(internal__static_google_protobuf_CSharpMethodOptions__Descriptor,
97	new string[] { "DispatchId", });
98	global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFileOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[0]);
99	global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFieldOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[1]);
100	global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpServiceOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[2]);
101	global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpMethodOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[3]);
102	return null;
103	};
104	pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
105	new pbd::FileDescriptor[] {
106	global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor,
107	}, assigner);
108	}
109	#endregion
110
111	}
112	#region Enums
113	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
114	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
115	public enum CSharpServiceType {
116	NONE = 0,
117	GENERIC = 1,
118	INTERFACE = 2,
119	IRPCDISPATCH = 3,
120	}
121
122	#endregion
123
124	#region Messages
125	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
126	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
127	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
128	public sealed partial class CSharpFileOptions : pb::GeneratedMessage<CSharpFileOptions, CSharpFileOptions.Builder> {
129	private CSharpFileOptions() { }
130	private static readonly CSharpFileOptions defaultInstance = new CSharpFileOptions().MakeReadOnly();
131	private static readonly string[] _cSharpFileOptionsFieldNames = new string[] { "add_serializable", "cls_compliance", "code_contracts", "expand_namespace_directories", "file_extension", "generate_private_ctor", "ignore_google_protobuf", "multiple_files", "namespace", "nest_classes", "output_directory", "public_classes", "service_generator_type", "umbrella_classname", "umbrella_namespace" };
132	private static readonly uint[] _cSharpFileOptionsFieldTags = new uint[] { 72, 64, 48, 56, 1770, 80, 1792, 32, 10, 40, 1786, 24, 1800, 18, 1778 };
133	public static CSharpFileOptions DefaultInstance {
134	get { return defaultInstance; }
135	}
136
137	public override CSharpFileOptions DefaultInstanceForType {
138	get { return DefaultInstance; }
139	}
140
141	protected override CSharpFileOptions ThisMessage {
142	get { return this; }
143	}
144
145	public static pbd::MessageDescriptor Descriptor {
146	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__Descriptor; }
147	}
148
149	protected override pb::FieldAccess.FieldAccessorTable<CSharpFileOptions, CSharpFileOptions.Builder> InternalFieldAccessors {
150	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable; }
151	}
152
153	public const int NamespaceFieldNumber = 1;
154	private bool hasNamespace;
155	private string namespace_ = "";
156	public bool HasNamespace {
157	get { return hasNamespace; }
158	}
159	public string Namespace {
160	get { return namespace_; }
161	}
162
163	public const int UmbrellaClassnameFieldNumber = 2;
164	private bool hasUmbrellaClassname;
165	private string umbrellaClassname_ = "";
166	public bool HasUmbrellaClassname {
167	get { return hasUmbrellaClassname; }
168	}
169	public string UmbrellaClassname {
170	get { return umbrellaClassname_; }
171	}
172
173	public const int PublicClassesFieldNumber = 3;
174	private bool hasPublicClasses;
175	private bool publicClasses_ = true;
176	public bool HasPublicClasses {
177	get { return hasPublicClasses; }
178	}
179	public bool PublicClasses {
180	get { return publicClasses_; }
181	}
182
183	public const int MultipleFilesFieldNumber = 4;
184	private bool hasMultipleFiles;
185	private bool multipleFiles_;
186	public bool HasMultipleFiles {
187	get { return hasMultipleFiles; }
188	}
189	public bool MultipleFiles {
190	get { return multipleFiles_; }
191	}
192
193	public const int NestClassesFieldNumber = 5;
194	private bool hasNestClasses;
195	private bool nestClasses_;
196	public bool HasNestClasses {
197	get { return hasNestClasses; }
198	}
199	public bool NestClasses {
200	get { return nestClasses_; }
201	}
202
203	public const int CodeContractsFieldNumber = 6;
204	private bool hasCodeContracts;
205	private bool codeContracts_;
206	public bool HasCodeContracts {
207	get { return hasCodeContracts; }
208	}
209	public bool CodeContracts {
210	get { return codeContracts_; }
211	}
212
213	public const int ExpandNamespaceDirectoriesFieldNumber = 7;
214	private bool hasExpandNamespaceDirectories;
215	private bool expandNamespaceDirectories_;
216	public bool HasExpandNamespaceDirectories {
217	get { return hasExpandNamespaceDirectories; }
218	}
219	public bool ExpandNamespaceDirectories {
220	get { return expandNamespaceDirectories_; }
221	}
222
223	public const int ClsComplianceFieldNumber = 8;
224	private bool hasClsCompliance;
225	private bool clsCompliance_ = true;
226	public bool HasClsCompliance {
227	get { return hasClsCompliance; }
228	}
229	public bool ClsCompliance {
230	get { return clsCompliance_; }
231	}
232
233	public const int AddSerializableFieldNumber = 9;
234	private bool hasAddSerializable;
235	private bool addSerializable_;
236	public bool HasAddSerializable {
237	get { return hasAddSerializable; }
238	}
239	public bool AddSerializable {
240	get { return addSerializable_; }
241	}
242
243	public const int GeneratePrivateCtorFieldNumber = 10;
244	private bool hasGeneratePrivateCtor;
245	private bool generatePrivateCtor_ = true;
246	public bool HasGeneratePrivateCtor {
247	get { return hasGeneratePrivateCtor; }
248	}
249	public bool GeneratePrivateCtor {
250	get { return generatePrivateCtor_; }
251	}
252
253	public const int FileExtensionFieldNumber = 221;
254	private bool hasFileExtension;
255	private string fileExtension_ = ".cs";
256	public bool HasFileExtension {
257	get { return hasFileExtension; }
258	}
259	public string FileExtension {
260	get { return fileExtension_; }
261	}
262
263	public const int UmbrellaNamespaceFieldNumber = 222;
264	private bool hasUmbrellaNamespace;
265	private string umbrellaNamespace_ = "";
266	public bool HasUmbrellaNamespace {
267	get { return hasUmbrellaNamespace; }
268	}
269	public string UmbrellaNamespace {
270	get { return umbrellaNamespace_; }
271	}
272
273	public const int OutputDirectoryFieldNumber = 223;
274	private bool hasOutputDirectory;
275	private string outputDirectory_ = ".";
276	public bool HasOutputDirectory {
277	get { return hasOutputDirectory; }
278	}
279	public string OutputDirectory {
280	get { return outputDirectory_; }
281	}
282
283	public const int IgnoreGoogleProtobufFieldNumber = 224;
284	private bool hasIgnoreGoogleProtobuf;
285	private bool ignoreGoogleProtobuf_;
286	public bool HasIgnoreGoogleProtobuf {
287	get { return hasIgnoreGoogleProtobuf; }
288	}
289	public bool IgnoreGoogleProtobuf {
290	get { return ignoreGoogleProtobuf_; }
291	}
292
293	public const int ServiceGeneratorTypeFieldNumber = 225;
294	private bool hasServiceGeneratorType;
295	private global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType serviceGeneratorType_ = global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType.NONE;
296	public bool HasServiceGeneratorType {
297	get { return hasServiceGeneratorType; }
298	}
299	public global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType ServiceGeneratorType {
300	get { return serviceGeneratorType_; }
301	}
302
303	public override bool IsInitialized {
304	get {
305	return true;
306	}
307	}
308
309	public override void WriteTo(pb::ICodedOutputStream output) {
310	int size = SerializedSize;
311	string[] field_names = _cSharpFileOptionsFieldNames;
312	if (hasNamespace) {
313	output.WriteString(1, field_names[8], Namespace);
314	}
315	if (hasUmbrellaClassname) {
316	output.WriteString(2, field_names[13], UmbrellaClassname);
317	}
318	if (hasPublicClasses) {
319	output.WriteBool(3, field_names[11], PublicClasses);
320	}
321	if (hasMultipleFiles) {
322	output.WriteBool(4, field_names[7], MultipleFiles);
323	}
324	if (hasNestClasses) {
325	output.WriteBool(5, field_names[9], NestClasses);
326	}
327	if (hasCodeContracts) {
328	output.WriteBool(6, field_names[2], CodeContracts);
329	}
330	if (hasExpandNamespaceDirectories) {
331	output.WriteBool(7, field_names[3], ExpandNamespaceDirectories);
332	}
333	if (hasClsCompliance) {
334	output.WriteBool(8, field_names[1], ClsCompliance);
335	}
336	if (hasAddSerializable) {
337	output.WriteBool(9, field_names[0], AddSerializable);
338	}
339	if (hasGeneratePrivateCtor) {
340	output.WriteBool(10, field_names[5], GeneratePrivateCtor);
341	}
342	if (hasFileExtension) {
343	output.WriteString(221, field_names[4], FileExtension);
344	}
345	if (hasUmbrellaNamespace) {
346	output.WriteString(222, field_names[14], UmbrellaNamespace);
347	}
348	if (hasOutputDirectory) {
349	output.WriteString(223, field_names[10], OutputDirectory);
350	}
351	if (hasIgnoreGoogleProtobuf) {
352	output.WriteBool(224, field_names[6], IgnoreGoogleProtobuf);
353	}
354	if (hasServiceGeneratorType) {
355	output.WriteEnum(225, field_names[12], (int) ServiceGeneratorType, ServiceGeneratorType);
356	}
357	UnknownFields.WriteTo(output);
358	}
359
360	private int memoizedSerializedSize = -1;
361	public override int SerializedSize {
362	get {
363	int size = memoizedSerializedSize;
364	if (size != -1) return size;
365
366	size = 0;
367	if (hasNamespace) {
368	size += pb::CodedOutputStream.ComputeStringSize(1, Namespace);
369	}
370	if (hasUmbrellaClassname) {
371	size += pb::CodedOutputStream.ComputeStringSize(2, UmbrellaClassname);
372	}
373	if (hasPublicClasses) {
374	size += pb::CodedOutputStream.ComputeBoolSize(3, PublicClasses);
375	}
376	if (hasMultipleFiles) {
377	size += pb::CodedOutputStream.ComputeBoolSize(4, MultipleFiles);
378	}
379	if (hasNestClasses) {
380	size += pb::CodedOutputStream.ComputeBoolSize(5, NestClasses);
381	}
382	if (hasCodeContracts) {
383	size += pb::CodedOutputStream.ComputeBoolSize(6, CodeContracts);
384	}
385	if (hasExpandNamespaceDirectories) {
386	size += pb::CodedOutputStream.ComputeBoolSize(7, ExpandNamespaceDirectories);
387	}
388	if (hasClsCompliance) {
389	size += pb::CodedOutputStream.ComputeBoolSize(8, ClsCompliance);
390	}
391	if (hasAddSerializable) {
392	size += pb::CodedOutputStream.ComputeBoolSize(9, AddSerializable);
393	}
394	if (hasGeneratePrivateCtor) {
395	size += pb::CodedOutputStream.ComputeBoolSize(10, GeneratePrivateCtor);
396	}
397	if (hasFileExtension) {
398	size += pb::CodedOutputStream.ComputeStringSize(221, FileExtension);
399	}
400	if (hasUmbrellaNamespace) {
401	size += pb::CodedOutputStream.ComputeStringSize(222, UmbrellaNamespace);
402	}
403	if (hasOutputDirectory) {
404	size += pb::CodedOutputStream.ComputeStringSize(223, OutputDirectory);
405	}
406	if (hasIgnoreGoogleProtobuf) {
407	size += pb::CodedOutputStream.ComputeBoolSize(224, IgnoreGoogleProtobuf);
408	}
409	if (hasServiceGeneratorType) {
410	size += pb::CodedOutputStream.ComputeEnumSize(225, (int) ServiceGeneratorType);
411	}
412	size += UnknownFields.SerializedSize;
413	memoizedSerializedSize = size;
414	return size;
415	}
416	}
417
418	public static CSharpFileOptions ParseFrom(pb::ByteString data) {
419	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
420	}
421	public static CSharpFileOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
422	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
423	}
424	public static CSharpFileOptions ParseFrom(byte[] data) {
425	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
426	}
427	public static CSharpFileOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
428	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
429	}
430	public static CSharpFileOptions ParseFrom(global::System.IO.Stream input) {
431	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
432	}
433	public static CSharpFileOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
434	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
435	}
436	public static CSharpFileOptions ParseDelimitedFrom(global::System.IO.Stream input) {
437	return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
438	}
439	public static CSharpFileOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
440	return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
441	}
442	public static CSharpFileOptions ParseFrom(pb::ICodedInputStream input) {
443	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
444	}
445	public static CSharpFileOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
446	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
447	}
448	private CSharpFileOptions MakeReadOnly() {
449	return this;
450	}
451
452	public static Builder CreateBuilder() { return new Builder(); }
453	public override Builder ToBuilder() { return CreateBuilder(this); }
454	public override Builder CreateBuilderForType() { return new Builder(); }
455	public static Builder CreateBuilder(CSharpFileOptions prototype) {
456	return new Builder(prototype);
457	}
458
459	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
460	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
461	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
462	public sealed partial class Builder : pb::GeneratedBuilder<CSharpFileOptions, Builder> {
463	protected override Builder ThisBuilder {
464	get { return this; }
465	}
466	public Builder() {
467	result = DefaultInstance;
468	resultIsReadOnly = true;
469	}
470	internal Builder(CSharpFileOptions cloneFrom) {
471	result = cloneFrom;
472	resultIsReadOnly = true;
473	}
474
475	private bool resultIsReadOnly;
476	private CSharpFileOptions result;
477
478	private CSharpFileOptions PrepareBuilder() {
479	if (resultIsReadOnly) {
480	CSharpFileOptions original = result;
481	result = new CSharpFileOptions();
482	resultIsReadOnly = false;
483	MergeFrom(original);
484	}
485	return result;
486	}
487
488	public override bool IsInitialized {
489	get { return result.IsInitialized; }
490	}
491
492	protected override CSharpFileOptions MessageBeingBuilt {
493	get { return PrepareBuilder(); }
494	}
495
496	public override Builder Clear() {
497	result = DefaultInstance;
498	resultIsReadOnly = true;
499	return this;
500	}
501
502	public override Builder Clone() {
503	if (resultIsReadOnly) {
504	return new Builder(result);
505	} else {
506	return new Builder().MergeFrom(result);
507	}
508	}
509
510	public override pbd::MessageDescriptor DescriptorForType {
511	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Descriptor; }
512	}
513
514	public override CSharpFileOptions DefaultInstanceForType {
515	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.DefaultInstance; }
516	}
517
518	public override CSharpFileOptions BuildPartial() {
519	if (resultIsReadOnly) {
520	return result;
521	}
522	resultIsReadOnly = true;
523	return result.MakeReadOnly();
524	}
525
526	public override Builder MergeFrom(pb::IMessage other) {
527	if (other is CSharpFileOptions) {
528	return MergeFrom((CSharpFileOptions) other);
529	} else {
530	base.MergeFrom(other);
531	return this;
532	}
533	}
534
535	public override Builder MergeFrom(CSharpFileOptions other) {
536	if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.DefaultInstance) return this;
537	PrepareBuilder();
538	if (other.HasNamespace) {
539	Namespace = other.Namespace;
540	}
541	if (other.HasUmbrellaClassname) {
542	UmbrellaClassname = other.UmbrellaClassname;
543	}
544	if (other.HasPublicClasses) {
545	PublicClasses = other.PublicClasses;
546	}
547	if (other.HasMultipleFiles) {
548	MultipleFiles = other.MultipleFiles;
549	}
550	if (other.HasNestClasses) {
551	NestClasses = other.NestClasses;
552	}
553	if (other.HasCodeContracts) {
554	CodeContracts = other.CodeContracts;
555	}
556	if (other.HasExpandNamespaceDirectories) {
557	ExpandNamespaceDirectories = other.ExpandNamespaceDirectories;
558	}
559	if (other.HasClsCompliance) {
560	ClsCompliance = other.ClsCompliance;
561	}
562	if (other.HasAddSerializable) {
563	AddSerializable = other.AddSerializable;
564	}
565	if (other.HasGeneratePrivateCtor) {
566	GeneratePrivateCtor = other.GeneratePrivateCtor;
567	}
568	if (other.HasFileExtension) {
569	FileExtension = other.FileExtension;
570	}
571	if (other.HasUmbrellaNamespace) {
572	UmbrellaNamespace = other.UmbrellaNamespace;
573	}
574	if (other.HasOutputDirectory) {
575	OutputDirectory = other.OutputDirectory;
576	}
577	if (other.HasIgnoreGoogleProtobuf) {
578	IgnoreGoogleProtobuf = other.IgnoreGoogleProtobuf;
579	}
580	if (other.HasServiceGeneratorType) {
581	ServiceGeneratorType = other.ServiceGeneratorType;
582	}
583	this.MergeUnknownFields(other.UnknownFields);
584	return this;
585	}
586
587	public override Builder MergeFrom(pb::ICodedInputStream input) {
588	return MergeFrom(input, pb::ExtensionRegistry.Empty);
589	}
590
591	public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
592	PrepareBuilder();
593	pb::UnknownFieldSet.Builder unknownFields = null;
594	uint tag;
595	string field_name;
596	while (input.ReadTag(out tag, out field_name)) {
597	if(tag == 0 && field_name != null) {
598	int field_ordinal = global::System.Array.BinarySearch(_cSharpFileOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
599	if(field_ordinal >= 0)
600	tag = _cSharpFileOptionsFieldTags[field_ordinal];
601	else {
602	if (unknownFields == null) {
603	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
604	}
605	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
606	continue;
607	}
608	}
609	switch (tag) {
610	case 0: {
611	throw pb::InvalidProtocolBufferException.InvalidTag();
612	}
613	default: {
614	if (pb::WireFormat.IsEndGroupTag(tag)) {
615	if (unknownFields != null) {
616	this.UnknownFields = unknownFields.Build();
617	}
618	return this;
619	}
620	if (unknownFields == null) {
621	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
622	}
623	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
624	break;
625	}
626	case 10: {
627	result.hasNamespace = input.ReadString(ref result.namespace_);
628	break;
629	}
630	case 18: {
631	result.hasUmbrellaClassname = input.ReadString(ref result.umbrellaClassname_);
632	break;
633	}
634	case 24: {
635	result.hasPublicClasses = input.ReadBool(ref result.publicClasses_);
636	break;
637	}
638	case 32: {
639	result.hasMultipleFiles = input.ReadBool(ref result.multipleFiles_);
640	break;
641	}
642	case 40: {
643	result.hasNestClasses = input.ReadBool(ref result.nestClasses_);
644	break;
645	}
646	case 48: {
647	result.hasCodeContracts = input.ReadBool(ref result.codeContracts_);
648	break;
649	}
650	case 56: {
651	result.hasExpandNamespaceDirectories = input.ReadBool(ref result.expandNamespaceDirectories_);
652	break;
653	}
654	case 64: {
655	result.hasClsCompliance = input.ReadBool(ref result.clsCompliance_);
656	break;
657	}
658	case 72: {
659	result.hasAddSerializable = input.ReadBool(ref result.addSerializable_);
660	break;
661	}
662	case 80: {
663	result.hasGeneratePrivateCtor = input.ReadBool(ref result.generatePrivateCtor_);
664	break;
665	}
666	case 1770: {
667	result.hasFileExtension = input.ReadString(ref result.fileExtension_);
668	break;
669	}
670	case 1778: {
671	result.hasUmbrellaNamespace = input.ReadString(ref result.umbrellaNamespace_);
672	break;
673	}
674	case 1786: {
675	result.hasOutputDirectory = input.ReadString(ref result.outputDirectory_);
676	break;
677	}
678	case 1792: {
679	result.hasIgnoreGoogleProtobuf = input.ReadBool(ref result.ignoreGoogleProtobuf_);
680	break;
681	}
682	case 1800: {
683	object unknown;
684	if(input.ReadEnum(ref result.serviceGeneratorType_, out unknown)) {
685	result.hasServiceGeneratorType = true;
686	} else if(unknown is int) {
687	if (unknownFields == null) {
688	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
689	}
690	unknownFields.MergeVarintField(225, (ulong)(int)unknown);
691	}
692	break;
693	}
694	}
695	}
696
697	if (unknownFields != null) {
698	this.UnknownFields = unknownFields.Build();
699	}
700	return this;
701	}
702
703
704	public bool HasNamespace {
705	get { return result.hasNamespace; }
706	}
707	public string Namespace {
708	get { return result.Namespace; }
709	set { SetNamespace(value); }
710	}
711	public Builder SetNamespace(string value) {
712	pb::ThrowHelper.ThrowIfNull(value, "value");
713	PrepareBuilder();
714	result.hasNamespace = true;
715	result.namespace_ = value;
716	return this;
717	}
718	public Builder ClearNamespace() {
719	PrepareBuilder();
720	result.hasNamespace = false;
721	result.namespace_ = "";
722	return this;
723	}
724
725	public bool HasUmbrellaClassname {
726	get { return result.hasUmbrellaClassname; }
727	}
728	public string UmbrellaClassname {
729	get { return result.UmbrellaClassname; }
730	set { SetUmbrellaClassname(value); }
731	}
732	public Builder SetUmbrellaClassname(string value) {
733	pb::ThrowHelper.ThrowIfNull(value, "value");
734	PrepareBuilder();
735	result.hasUmbrellaClassname = true;
736	result.umbrellaClassname_ = value;
737	return this;
738	}
739	public Builder ClearUmbrellaClassname() {
740	PrepareBuilder();
741	result.hasUmbrellaClassname = false;
742	result.umbrellaClassname_ = "";
743	return this;
744	}
745
746	public bool HasPublicClasses {
747	get { return result.hasPublicClasses; }
748	}
749	public bool PublicClasses {
750	get { return result.PublicClasses; }
751	set { SetPublicClasses(value); }
752	}
753	public Builder SetPublicClasses(bool value) {
754	PrepareBuilder();
755	result.hasPublicClasses = true;
756	result.publicClasses_ = value;
757	return this;
758	}
759	public Builder ClearPublicClasses() {
760	PrepareBuilder();
761	result.hasPublicClasses = false;
762	result.publicClasses_ = true;
763	return this;
764	}
765
766	public bool HasMultipleFiles {
767	get { return result.hasMultipleFiles; }
768	}
769	public bool MultipleFiles {
770	get { return result.MultipleFiles; }
771	set { SetMultipleFiles(value); }
772	}
773	public Builder SetMultipleFiles(bool value) {
774	PrepareBuilder();
775	result.hasMultipleFiles = true;
776	result.multipleFiles_ = value;
777	return this;
778	}
779	public Builder ClearMultipleFiles() {
780	PrepareBuilder();
781	result.hasMultipleFiles = false;
782	result.multipleFiles_ = false;
783	return this;
784	}
785
786	public bool HasNestClasses {
787	get { return result.hasNestClasses; }
788	}
789	public bool NestClasses {
790	get { return result.NestClasses; }
791	set { SetNestClasses(value); }
792	}
793	public Builder SetNestClasses(bool value) {
794	PrepareBuilder();
795	result.hasNestClasses = true;
796	result.nestClasses_ = value;
797	return this;
798	}
799	public Builder ClearNestClasses() {
800	PrepareBuilder();
801	result.hasNestClasses = false;
802	result.nestClasses_ = false;
803	return this;
804	}
805
806	public bool HasCodeContracts {
807	get { return result.hasCodeContracts; }
808	}
809	public bool CodeContracts {
810	get { return result.CodeContracts; }
811	set { SetCodeContracts(value); }
812	}
813	public Builder SetCodeContracts(bool value) {
814	PrepareBuilder();
815	result.hasCodeContracts = true;
816	result.codeContracts_ = value;
817	return this;
818	}
819	public Builder ClearCodeContracts() {
820	PrepareBuilder();
821	result.hasCodeContracts = false;
822	result.codeContracts_ = false;
823	return this;
824	}
825
826	public bool HasExpandNamespaceDirectories {
827	get { return result.hasExpandNamespaceDirectories; }
828	}
829	public bool ExpandNamespaceDirectories {
830	get { return result.ExpandNamespaceDirectories; }
831	set { SetExpandNamespaceDirectories(value); }
832	}
833	public Builder SetExpandNamespaceDirectories(bool value) {
834	PrepareBuilder();
835	result.hasExpandNamespaceDirectories = true;
836	result.expandNamespaceDirectories_ = value;
837	return this;
838	}
839	public Builder ClearExpandNamespaceDirectories() {
840	PrepareBuilder();
841	result.hasExpandNamespaceDirectories = false;
842	result.expandNamespaceDirectories_ = false;
843	return this;
844	}
845
846	public bool HasClsCompliance {
847	get { return result.hasClsCompliance; }
848	}
849	public bool ClsCompliance {
850	get { return result.ClsCompliance; }
851	set { SetClsCompliance(value); }
852	}
853	public Builder SetClsCompliance(bool value) {
854	PrepareBuilder();
855	result.hasClsCompliance = true;
856	result.clsCompliance_ = value;
857	return this;
858	}
859	public Builder ClearClsCompliance() {
860	PrepareBuilder();
861	result.hasClsCompliance = false;
862	result.clsCompliance_ = true;
863	return this;
864	}
865
866	public bool HasAddSerializable {
867	get { return result.hasAddSerializable; }
868	}
869	public bool AddSerializable {
870	get { return result.AddSerializable; }
871	set { SetAddSerializable(value); }
872	}
873	public Builder SetAddSerializable(bool value) {
874	PrepareBuilder();
875	result.hasAddSerializable = true;
876	result.addSerializable_ = value;
877	return this;
878	}
879	public Builder ClearAddSerializable() {
880	PrepareBuilder();
881	result.hasAddSerializable = false;
882	result.addSerializable_ = false;
883	return this;
884	}
885
886	public bool HasGeneratePrivateCtor {
887	get { return result.hasGeneratePrivateCtor; }
888	}
889	public bool GeneratePrivateCtor {
890	get { return result.GeneratePrivateCtor; }
891	set { SetGeneratePrivateCtor(value); }
892	}
893	public Builder SetGeneratePrivateCtor(bool value) {
894	PrepareBuilder();
895	result.hasGeneratePrivateCtor = true;
896	result.generatePrivateCtor_ = value;
897	return this;
898	}
899	public Builder ClearGeneratePrivateCtor() {
900	PrepareBuilder();
901	result.hasGeneratePrivateCtor = false;
902	result.generatePrivateCtor_ = true;
903	return this;
904	}
905
906	public bool HasFileExtension {
907	get { return result.hasFileExtension; }
908	}
909	public string FileExtension {
910	get { return result.FileExtension; }
911	set { SetFileExtension(value); }
912	}
913	public Builder SetFileExtension(string value) {
914	pb::ThrowHelper.ThrowIfNull(value, "value");
915	PrepareBuilder();
916	result.hasFileExtension = true;
917	result.fileExtension_ = value;
918	return this;
919	}
920	public Builder ClearFileExtension() {
921	PrepareBuilder();
922	result.hasFileExtension = false;
923	result.fileExtension_ = ".cs";
924	return this;
925	}
926
927	public bool HasUmbrellaNamespace {
928	get { return result.hasUmbrellaNamespace; }
929	}
930	public string UmbrellaNamespace {
931	get { return result.UmbrellaNamespace; }
932	set { SetUmbrellaNamespace(value); }
933	}
934	public Builder SetUmbrellaNamespace(string value) {
935	pb::ThrowHelper.ThrowIfNull(value, "value");
936	PrepareBuilder();
937	result.hasUmbrellaNamespace = true;
938	result.umbrellaNamespace_ = value;
939	return this;
940	}
941	public Builder ClearUmbrellaNamespace() {
942	PrepareBuilder();
943	result.hasUmbrellaNamespace = false;
944	result.umbrellaNamespace_ = "";
945	return this;
946	}
947
948	public bool HasOutputDirectory {
949	get { return result.hasOutputDirectory; }
950	}
951	public string OutputDirectory {
952	get { return result.OutputDirectory; }
953	set { SetOutputDirectory(value); }
954	}
955	public Builder SetOutputDirectory(string value) {
956	pb::ThrowHelper.ThrowIfNull(value, "value");
957	PrepareBuilder();
958	result.hasOutputDirectory = true;
959	result.outputDirectory_ = value;
960	return this;
961	}
962	public Builder ClearOutputDirectory() {
963	PrepareBuilder();
964	result.hasOutputDirectory = false;
965	result.outputDirectory_ = ".";
966	return this;
967	}
968
969	public bool HasIgnoreGoogleProtobuf {
970	get { return result.hasIgnoreGoogleProtobuf; }
971	}
972	public bool IgnoreGoogleProtobuf {
973	get { return result.IgnoreGoogleProtobuf; }
974	set { SetIgnoreGoogleProtobuf(value); }
975	}
976	public Builder SetIgnoreGoogleProtobuf(bool value) {
977	PrepareBuilder();
978	result.hasIgnoreGoogleProtobuf = true;
979	result.ignoreGoogleProtobuf_ = value;
980	return this;
981	}
982	public Builder ClearIgnoreGoogleProtobuf() {
983	PrepareBuilder();
984	result.hasIgnoreGoogleProtobuf = false;
985	result.ignoreGoogleProtobuf_ = false;
986	return this;
987	}
988
989	public bool HasServiceGeneratorType {
990	get { return result.hasServiceGeneratorType; }
991	}
992	public global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType ServiceGeneratorType {
993	get { return result.ServiceGeneratorType; }
994	set { SetServiceGeneratorType(value); }
995	}
996	public Builder SetServiceGeneratorType(global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType value) {
997	PrepareBuilder();
998	result.hasServiceGeneratorType = true;
999	result.serviceGeneratorType_ = value;
1000	return this;
1001	}
1002	public Builder ClearServiceGeneratorType() {
1003	PrepareBuilder();
1004	result.hasServiceGeneratorType = false;
1005	result.serviceGeneratorType_ = global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType.NONE;
1006	return this;
1007	}
1008	}
1009	static CSharpFileOptions() {
1010	object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
1011	}
1012	}
1013
1014	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
1015	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
1016	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
1017	public sealed partial class CSharpFieldOptions : pb::GeneratedMessage<CSharpFieldOptions, CSharpFieldOptions.Builder> {
1018	private CSharpFieldOptions() { }
1019	private static readonly CSharpFieldOptions defaultInstance = new CSharpFieldOptions().MakeReadOnly();
1020	private static readonly string[] _cSharpFieldOptionsFieldNames = new string[] { "property_name" };
1021	private static readonly uint[] _cSharpFieldOptionsFieldTags = new uint[] { 10 };
1022	public static CSharpFieldOptions DefaultInstance {
1023	get { return defaultInstance; }
1024	}
1025
1026	public override CSharpFieldOptions DefaultInstanceForType {
1027	get { return DefaultInstance; }
1028	}
1029
1030	protected override CSharpFieldOptions ThisMessage {
1031	get { return this; }
1032	}
1033
1034	public static pbd::MessageDescriptor Descriptor {
1035	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__Descriptor; }
1036	}
1037
1038	protected override pb::FieldAccess.FieldAccessorTable<CSharpFieldOptions, CSharpFieldOptions.Builder> InternalFieldAccessors {
1039	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable; }
1040	}
1041
1042	public const int PropertyNameFieldNumber = 1;
1043	private bool hasPropertyName;
1044	private string propertyName_ = "";
1045	public bool HasPropertyName {
1046	get { return hasPropertyName; }
1047	}
1048	public string PropertyName {
1049	get { return propertyName_; }
1050	}
1051
1052	public override bool IsInitialized {
1053	get {
1054	return true;
1055	}
1056	}
1057
1058	public override void WriteTo(pb::ICodedOutputStream output) {
1059	int size = SerializedSize;
1060	string[] field_names = _cSharpFieldOptionsFieldNames;
1061	if (hasPropertyName) {
1062	output.WriteString(1, field_names[0], PropertyName);
1063	}
1064	UnknownFields.WriteTo(output);
1065	}
1066
1067	private int memoizedSerializedSize = -1;
1068	public override int SerializedSize {
1069	get {
1070	int size = memoizedSerializedSize;
1071	if (size != -1) return size;
1072
1073	size = 0;
1074	if (hasPropertyName) {
1075	size += pb::CodedOutputStream.ComputeStringSize(1, PropertyName);
1076	}
1077	size += UnknownFields.SerializedSize;
1078	memoizedSerializedSize = size;
1079	return size;
1080	}
1081	}
1082
1083	public static CSharpFieldOptions ParseFrom(pb::ByteString data) {
1084	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
1085	}
1086	public static CSharpFieldOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
1087	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
1088	}
1089	public static CSharpFieldOptions ParseFrom(byte[] data) {
1090	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
1091	}
1092	public static CSharpFieldOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
1093	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
1094	}
1095	public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input) {
1096	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
1097	}
1098	public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
1099	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
1100	}
1101	public static CSharpFieldOptions ParseDelimitedFrom(global::System.IO.Stream input) {
1102	return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
1103	}
1104	public static CSharpFieldOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
1105	return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
1106	}
1107	public static CSharpFieldOptions ParseFrom(pb::ICodedInputStream input) {
1108	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
1109	}
1110	public static CSharpFieldOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
1111	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
1112	}
1113	private CSharpFieldOptions MakeReadOnly() {
1114	return this;
1115	}
1116
1117	public static Builder CreateBuilder() { return new Builder(); }
1118	public override Builder ToBuilder() { return CreateBuilder(this); }
1119	public override Builder CreateBuilderForType() { return new Builder(); }
1120	public static Builder CreateBuilder(CSharpFieldOptions prototype) {
1121	return new Builder(prototype);
1122	}
1123
1124	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
1125	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
1126	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
1127	public sealed partial class Builder : pb::GeneratedBuilder<CSharpFieldOptions, Builder> {
1128	protected override Builder ThisBuilder {
1129	get { return this; }
1130	}
1131	public Builder() {
1132	result = DefaultInstance;
1133	resultIsReadOnly = true;
1134	}
1135	internal Builder(CSharpFieldOptions cloneFrom) {
1136	result = cloneFrom;
1137	resultIsReadOnly = true;
1138	}
1139
1140	private bool resultIsReadOnly;
1141	private CSharpFieldOptions result;
1142
1143	private CSharpFieldOptions PrepareBuilder() {
1144	if (resultIsReadOnly) {
1145	CSharpFieldOptions original = result;
1146	result = new CSharpFieldOptions();
1147	resultIsReadOnly = false;
1148	MergeFrom(original);
1149	}
1150	return result;
1151	}
1152
1153	public override bool IsInitialized {
1154	get { return result.IsInitialized; }
1155	}
1156
1157	protected override CSharpFieldOptions MessageBeingBuilt {
1158	get { return PrepareBuilder(); }
1159	}
1160
1161	public override Builder Clear() {
1162	result = DefaultInstance;
1163	resultIsReadOnly = true;
1164	return this;
1165	}
1166
1167	public override Builder Clone() {
1168	if (resultIsReadOnly) {
1169	return new Builder(result);
1170	} else {
1171	return new Builder().MergeFrom(result);
1172	}
1173	}
1174
1175	public override pbd::MessageDescriptor DescriptorForType {
1176	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Descriptor; }
1177	}
1178
1179	public override CSharpFieldOptions DefaultInstanceForType {
1180	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.DefaultInstance; }
1181	}
1182
1183	public override CSharpFieldOptions BuildPartial() {
1184	if (resultIsReadOnly) {
1185	return result;
1186	}
1187	resultIsReadOnly = true;
1188	return result.MakeReadOnly();
1189	}
1190
1191	public override Builder MergeFrom(pb::IMessage other) {
1192	if (other is CSharpFieldOptions) {
1193	return MergeFrom((CSharpFieldOptions) other);
1194	} else {
1195	base.MergeFrom(other);
1196	return this;
1197	}
1198	}
1199
1200	public override Builder MergeFrom(CSharpFieldOptions other) {
1201	if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.DefaultInstance) return this;
1202	PrepareBuilder();
1203	if (other.HasPropertyName) {
1204	PropertyName = other.PropertyName;
1205	}
1206	this.MergeUnknownFields(other.UnknownFields);
1207	return this;
1208	}
1209
1210	public override Builder MergeFrom(pb::ICodedInputStream input) {
1211	return MergeFrom(input, pb::ExtensionRegistry.Empty);
1212	}
1213
1214	public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
1215	PrepareBuilder();
1216	pb::UnknownFieldSet.Builder unknownFields = null;
1217	uint tag;
1218	string field_name;
1219	while (input.ReadTag(out tag, out field_name)) {
1220	if(tag == 0 && field_name != null) {
1221	int field_ordinal = global::System.Array.BinarySearch(_cSharpFieldOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
1222	if(field_ordinal >= 0)
1223	tag = _cSharpFieldOptionsFieldTags[field_ordinal];
1224	else {
1225	if (unknownFields == null) {
1226	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
1227	}
1228	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
1229	continue;
1230	}
1231	}
1232	switch (tag) {
1233	case 0: {
1234	throw pb::InvalidProtocolBufferException.InvalidTag();
1235	}
1236	default: {
1237	if (pb::WireFormat.IsEndGroupTag(tag)) {
1238	if (unknownFields != null) {
1239	this.UnknownFields = unknownFields.Build();
1240	}
1241	return this;
1242	}
1243	if (unknownFields == null) {
1244	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
1245	}
1246	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
1247	break;
1248	}
1249	case 10: {
1250	result.hasPropertyName = input.ReadString(ref result.propertyName_);
1251	break;
1252	}
1253	}
1254	}
1255
1256	if (unknownFields != null) {
1257	this.UnknownFields = unknownFields.Build();
1258	}
1259	return this;
1260	}
1261
1262
1263	public bool HasPropertyName {
1264	get { return result.hasPropertyName; }
1265	}
1266	public string PropertyName {
1267	get { return result.PropertyName; }
1268	set { SetPropertyName(value); }
1269	}
1270	public Builder SetPropertyName(string value) {
1271	pb::ThrowHelper.ThrowIfNull(value, "value");
1272	PrepareBuilder();
1273	result.hasPropertyName = true;
1274	result.propertyName_ = value;
1275	return this;
1276	}
1277	public Builder ClearPropertyName() {
1278	PrepareBuilder();
1279	result.hasPropertyName = false;
1280	result.propertyName_ = "";
1281	return this;
1282	}
1283	}
1284	static CSharpFieldOptions() {
1285	object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
1286	}
1287	}
1288
1289	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
1290	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
1291	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
1292	public sealed partial class CSharpServiceOptions : pb::GeneratedMessage<CSharpServiceOptions, CSharpServiceOptions.Builder> {
1293	private CSharpServiceOptions() { }
1294	private static readonly CSharpServiceOptions defaultInstance = new CSharpServiceOptions().MakeReadOnly();
1295	private static readonly string[] _cSharpServiceOptionsFieldNames = new string[] { "interface_id" };
1296	private static readonly uint[] _cSharpServiceOptionsFieldTags = new uint[] { 10 };
1297	public static CSharpServiceOptions DefaultInstance {
1298	get { return defaultInstance; }
1299	}
1300
1301	public override CSharpServiceOptions DefaultInstanceForType {
1302	get { return DefaultInstance; }
1303	}
1304
1305	protected override CSharpServiceOptions ThisMessage {
1306	get { return this; }
1307	}
1308
1309	public static pbd::MessageDescriptor Descriptor {
1310	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpServiceOptions__Descriptor; }
1311	}
1312
1313	protected override pb::FieldAccess.FieldAccessorTable<CSharpServiceOptions, CSharpServiceOptions.Builder> InternalFieldAccessors {
1314	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable; }
1315	}
1316
1317	public const int InterfaceIdFieldNumber = 1;
1318	private bool hasInterfaceId;
1319	private string interfaceId_ = "";
1320	public bool HasInterfaceId {
1321	get { return hasInterfaceId; }
1322	}
1323	public string InterfaceId {
1324	get { return interfaceId_; }
1325	}
1326
1327	public override bool IsInitialized {
1328	get {
1329	return true;
1330	}
1331	}
1332
1333	public override void WriteTo(pb::ICodedOutputStream output) {
1334	int size = SerializedSize;
1335	string[] field_names = _cSharpServiceOptionsFieldNames;
1336	if (hasInterfaceId) {
1337	output.WriteString(1, field_names[0], InterfaceId);
1338	}
1339	UnknownFields.WriteTo(output);
1340	}
1341
1342	private int memoizedSerializedSize = -1;
1343	public override int SerializedSize {
1344	get {
1345	int size = memoizedSerializedSize;
1346	if (size != -1) return size;
1347
1348	size = 0;
1349	if (hasInterfaceId) {
1350	size += pb::CodedOutputStream.ComputeStringSize(1, InterfaceId);
1351	}
1352	size += UnknownFields.SerializedSize;
1353	memoizedSerializedSize = size;
1354	return size;
1355	}
1356	}
1357
1358	public static CSharpServiceOptions ParseFrom(pb::ByteString data) {
1359	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
1360	}
1361	public static CSharpServiceOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
1362	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
1363	}
1364	public static CSharpServiceOptions ParseFrom(byte[] data) {
1365	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
1366	}
1367	public static CSharpServiceOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
1368	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
1369	}
1370	public static CSharpServiceOptions ParseFrom(global::System.IO.Stream input) {
1371	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
1372	}
1373	public static CSharpServiceOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
1374	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
1375	}
1376	public static CSharpServiceOptions ParseDelimitedFrom(global::System.IO.Stream input) {
1377	return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
1378	}
1379	public static CSharpServiceOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
1380	return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
1381	}
1382	public static CSharpServiceOptions ParseFrom(pb::ICodedInputStream input) {
1383	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
1384	}
1385	public static CSharpServiceOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
1386	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
1387	}
1388	private CSharpServiceOptions MakeReadOnly() {
1389	return this;
1390	}
1391
1392	public static Builder CreateBuilder() { return new Builder(); }
1393	public override Builder ToBuilder() { return CreateBuilder(this); }
1394	public override Builder CreateBuilderForType() { return new Builder(); }
1395	public static Builder CreateBuilder(CSharpServiceOptions prototype) {
1396	return new Builder(prototype);
1397	}
1398
1399	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
1400	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
1401	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
1402	public sealed partial class Builder : pb::GeneratedBuilder<CSharpServiceOptions, Builder> {
1403	protected override Builder ThisBuilder {
1404	get { return this; }
1405	}
1406	public Builder() {
1407	result = DefaultInstance;
1408	resultIsReadOnly = true;
1409	}
1410	internal Builder(CSharpServiceOptions cloneFrom) {
1411	result = cloneFrom;
1412	resultIsReadOnly = true;
1413	}
1414
1415	private bool resultIsReadOnly;
1416	private CSharpServiceOptions result;
1417
1418	private CSharpServiceOptions PrepareBuilder() {
1419	if (resultIsReadOnly) {
1420	CSharpServiceOptions original = result;
1421	result = new CSharpServiceOptions();
1422	resultIsReadOnly = false;
1423	MergeFrom(original);
1424	}
1425	return result;
1426	}
1427
1428	public override bool IsInitialized {
1429	get { return result.IsInitialized; }
1430	}
1431
1432	protected override CSharpServiceOptions MessageBeingBuilt {
1433	get { return PrepareBuilder(); }
1434	}
1435
1436	public override Builder Clear() {
1437	result = DefaultInstance;
1438	resultIsReadOnly = true;
1439	return this;
1440	}
1441
1442	public override Builder Clone() {
1443	if (resultIsReadOnly) {
1444	return new Builder(result);
1445	} else {
1446	return new Builder().MergeFrom(result);
1447	}
1448	}
1449
1450	public override pbd::MessageDescriptor DescriptorForType {
1451	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Descriptor; }
1452	}
1453
1454	public override CSharpServiceOptions DefaultInstanceForType {
1455	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.DefaultInstance; }
1456	}
1457
1458	public override CSharpServiceOptions BuildPartial() {
1459	if (resultIsReadOnly) {
1460	return result;
1461	}
1462	resultIsReadOnly = true;
1463	return result.MakeReadOnly();
1464	}
1465
1466	public override Builder MergeFrom(pb::IMessage other) {
1467	if (other is CSharpServiceOptions) {
1468	return MergeFrom((CSharpServiceOptions) other);
1469	} else {
1470	base.MergeFrom(other);
1471	return this;
1472	}
1473	}
1474
1475	public override Builder MergeFrom(CSharpServiceOptions other) {
1476	if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.DefaultInstance) return this;
1477	PrepareBuilder();
1478	if (other.HasInterfaceId) {
1479	InterfaceId = other.InterfaceId;
1480	}
1481	this.MergeUnknownFields(other.UnknownFields);
1482	return this;
1483	}
1484
1485	public override Builder MergeFrom(pb::ICodedInputStream input) {
1486	return MergeFrom(input, pb::ExtensionRegistry.Empty);
1487	}
1488
1489	public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
1490	PrepareBuilder();
1491	pb::UnknownFieldSet.Builder unknownFields = null;
1492	uint tag;
1493	string field_name;
1494	while (input.ReadTag(out tag, out field_name)) {
1495	if(tag == 0 && field_name != null) {
1496	int field_ordinal = global::System.Array.BinarySearch(_cSharpServiceOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
1497	if(field_ordinal >= 0)
1498	tag = _cSharpServiceOptionsFieldTags[field_ordinal];
1499	else {
1500	if (unknownFields == null) {
1501	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
1502	}
1503	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
1504	continue;
1505	}
1506	}
1507	switch (tag) {
1508	case 0: {
1509	throw pb::InvalidProtocolBufferException.InvalidTag();
1510	}
1511	default: {
1512	if (pb::WireFormat.IsEndGroupTag(tag)) {
1513	if (unknownFields != null) {
1514	this.UnknownFields = unknownFields.Build();
1515	}
1516	return this;
1517	}
1518	if (unknownFields == null) {
1519	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
1520	}
1521	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
1522	break;
1523	}
1524	case 10: {
1525	result.hasInterfaceId = input.ReadString(ref result.interfaceId_);
1526	break;
1527	}
1528	}
1529	}
1530
1531	if (unknownFields != null) {
1532	this.UnknownFields = unknownFields.Build();
1533	}
1534	return this;
1535	}
1536
1537
1538	public bool HasInterfaceId {
1539	get { return result.hasInterfaceId; }
1540	}
1541	public string InterfaceId {
1542	get { return result.InterfaceId; }
1543	set { SetInterfaceId(value); }
1544	}
1545	public Builder SetInterfaceId(string value) {
1546	pb::ThrowHelper.ThrowIfNull(value, "value");
1547	PrepareBuilder();
1548	result.hasInterfaceId = true;
1549	result.interfaceId_ = value;
1550	return this;
1551	}
1552	public Builder ClearInterfaceId() {
1553	PrepareBuilder();
1554	result.hasInterfaceId = false;
1555	result.interfaceId_ = "";
1556	return this;
1557	}
1558	}
1559	static CSharpServiceOptions() {
1560	object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
1561	}
1562	}
1563
1564	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
1565	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
1566	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
1567	public sealed partial class CSharpMethodOptions : pb::GeneratedMessage<CSharpMethodOptions, CSharpMethodOptions.Builder> {
1568	private CSharpMethodOptions() { }
1569	private static readonly CSharpMethodOptions defaultInstance = new CSharpMethodOptions().MakeReadOnly();
1570	private static readonly string[] _cSharpMethodOptionsFieldNames = new string[] { "dispatch_id" };
1571	private static readonly uint[] _cSharpMethodOptionsFieldTags = new uint[] { 8 };
1572	public static CSharpMethodOptions DefaultInstance {
1573	get { return defaultInstance; }
1574	}
1575
1576	public override CSharpMethodOptions DefaultInstanceForType {
1577	get { return DefaultInstance; }
1578	}
1579
1580	protected override CSharpMethodOptions ThisMessage {
1581	get { return this; }
1582	}
1583
1584	public static pbd::MessageDescriptor Descriptor {
1585	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpMethodOptions__Descriptor; }
1586	}
1587
1588	protected override pb::FieldAccess.FieldAccessorTable<CSharpMethodOptions, CSharpMethodOptions.Builder> InternalFieldAccessors {
1589	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable; }
1590	}
1591
1592	public const int DispatchIdFieldNumber = 1;
1593	private bool hasDispatchId;
1594	private int dispatchId_;
1595	public bool HasDispatchId {
1596	get { return hasDispatchId; }
1597	}
1598	public int DispatchId {
1599	get { return dispatchId_; }
1600	}
1601
1602	public override bool IsInitialized {
1603	get {
1604	return true;
1605	}
1606	}
1607
1608	public override void WriteTo(pb::ICodedOutputStream output) {
1609	int size = SerializedSize;
1610	string[] field_names = _cSharpMethodOptionsFieldNames;
1611	if (hasDispatchId) {
1612	output.WriteInt32(1, field_names[0], DispatchId);
1613	}
1614	UnknownFields.WriteTo(output);
1615	}
1616
1617	private int memoizedSerializedSize = -1;
1618	public override int SerializedSize {
1619	get {
1620	int size = memoizedSerializedSize;
1621	if (size != -1) return size;
1622
1623	size = 0;
1624	if (hasDispatchId) {
1625	size += pb::CodedOutputStream.ComputeInt32Size(1, DispatchId);
1626	}
1627	size += UnknownFields.SerializedSize;
1628	memoizedSerializedSize = size;
1629	return size;
1630	}
1631	}
1632
1633	public static CSharpMethodOptions ParseFrom(pb::ByteString data) {
1634	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
1635	}
1636	public static CSharpMethodOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
1637	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
1638	}
1639	public static CSharpMethodOptions ParseFrom(byte[] data) {
1640	return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
1641	}
1642	public static CSharpMethodOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
1643	return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
1644	}
1645	public static CSharpMethodOptions ParseFrom(global::System.IO.Stream input) {
1646	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
1647	}
1648	public static CSharpMethodOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
1649	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
1650	}
1651	public static CSharpMethodOptions ParseDelimitedFrom(global::System.IO.Stream input) {
1652	return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
1653	}
1654	public static CSharpMethodOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
1655	return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
1656	}
1657	public static CSharpMethodOptions ParseFrom(pb::ICodedInputStream input) {
1658	return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
1659	}
1660	public static CSharpMethodOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
1661	return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
1662	}
1663	private CSharpMethodOptions MakeReadOnly() {
1664	return this;
1665	}
1666
1667	public static Builder CreateBuilder() { return new Builder(); }
1668	public override Builder ToBuilder() { return CreateBuilder(this); }
1669	public override Builder CreateBuilderForType() { return new Builder(); }
1670	public static Builder CreateBuilder(CSharpMethodOptions prototype) {
1671	return new Builder(prototype);
1672	}
1673
1674	[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
1675	[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
1676	[global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
1677	public sealed partial class Builder : pb::GeneratedBuilder<CSharpMethodOptions, Builder> {
1678	protected override Builder ThisBuilder {
1679	get { return this; }
1680	}
1681	public Builder() {
1682	result = DefaultInstance;
1683	resultIsReadOnly = true;
1684	}
1685	internal Builder(CSharpMethodOptions cloneFrom) {
1686	result = cloneFrom;
1687	resultIsReadOnly = true;
1688	}
1689
1690	private bool resultIsReadOnly;
1691	private CSharpMethodOptions result;
1692
1693	private CSharpMethodOptions PrepareBuilder() {
1694	if (resultIsReadOnly) {
1695	CSharpMethodOptions original = result;
1696	result = new CSharpMethodOptions();
1697	resultIsReadOnly = false;
1698	MergeFrom(original);
1699	}
1700	return result;
1701	}
1702
1703	public override bool IsInitialized {
1704	get { return result.IsInitialized; }
1705	}
1706
1707	protected override CSharpMethodOptions MessageBeingBuilt {
1708	get { return PrepareBuilder(); }
1709	}
1710
1711	public override Builder Clear() {
1712	result = DefaultInstance;
1713	resultIsReadOnly = true;
1714	return this;
1715	}
1716
1717	public override Builder Clone() {
1718	if (resultIsReadOnly) {
1719	return new Builder(result);
1720	} else {
1721	return new Builder().MergeFrom(result);
1722	}
1723	}
1724
1725	public override pbd::MessageDescriptor DescriptorForType {
1726	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Descriptor; }
1727	}
1728
1729	public override CSharpMethodOptions DefaultInstanceForType {
1730	get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.DefaultInstance; }
1731	}
1732
1733	public override CSharpMethodOptions BuildPartial() {
1734	if (resultIsReadOnly) {
1735	return result;
1736	}
1737	resultIsReadOnly = true;
1738	return result.MakeReadOnly();
1739	}
1740
1741	public override Builder MergeFrom(pb::IMessage other) {
1742	if (other is CSharpMethodOptions) {
1743	return MergeFrom((CSharpMethodOptions) other);
1744	} else {
1745	base.MergeFrom(other);
1746	return this;
1747	}
1748	}
1749
1750	public override Builder MergeFrom(CSharpMethodOptions other) {
1751	if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.DefaultInstance) return this;
1752	PrepareBuilder();
1753	if (other.HasDispatchId) {
1754	DispatchId = other.DispatchId;
1755	}
1756	this.MergeUnknownFields(other.UnknownFields);
1757	return this;
1758	}
1759
1760	public override Builder MergeFrom(pb::ICodedInputStream input) {
1761	return MergeFrom(input, pb::ExtensionRegistry.Empty);
1762	}
1763
1764	public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
1765	PrepareBuilder();
1766	pb::UnknownFieldSet.Builder unknownFields = null;
1767	uint tag;
1768	string field_name;
1769	while (input.ReadTag(out tag, out field_name)) {
1770	if(tag == 0 && field_name != null) {
1771	int field_ordinal = global::System.Array.BinarySearch(_cSharpMethodOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
1772	if(field_ordinal >= 0)
1773	tag = _cSharpMethodOptionsFieldTags[field_ordinal];
1774	else {
1775	if (unknownFields == null) {
1776	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
1777	}
1778	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
1779	continue;
1780	}
1781	}
1782	switch (tag) {
1783	case 0: {
1784	throw pb::InvalidProtocolBufferException.InvalidTag();
1785	}
1786	default: {
1787	if (pb::WireFormat.IsEndGroupTag(tag)) {
1788	if (unknownFields != null) {
1789	this.UnknownFields = unknownFields.Build();
1790	}
1791	return this;
1792	}
1793	if (unknownFields == null) {
1794	unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
1795	}
1796	ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
1797	break;
1798	}
1799	case 8: {
1800	result.hasDispatchId = input.ReadInt32(ref result.dispatchId_);
1801	break;
1802	}
1803	}
1804	}
1805
1806	if (unknownFields != null) {
1807	this.UnknownFields = unknownFields.Build();
1808	}
1809	return this;
1810	}
1811
1812
1813	public bool HasDispatchId {
1814	get { return result.hasDispatchId; }
1815	}
1816	public int DispatchId {
1817	get { return result.DispatchId; }
1818	set { SetDispatchId(value); }
1819	}
1820	public Builder SetDispatchId(int value) {
1821	PrepareBuilder();
1822	result.hasDispatchId = true;
1823	result.dispatchId_ = value;
1824	return this;
1825	}
1826	public Builder ClearDispatchId() {
1827	PrepareBuilder();
1828	result.hasDispatchId = false;
1829	result.dispatchId_ = 0;
1830	return this;
1831	}
1832	}
1833	static CSharpMethodOptions() {
1834	object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
1835	}
1836	}
1837
1838	#endregion
1839
1840	}
1841
1842	#endregion Designer generated code

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences