diff options
author | Jonathan Freedman | 2010-10-05 20:06:27 -0400 |
---|---|---|
committer | Jonathan Freedman | 2010-10-05 20:06:27 -0400 |
commit | 84cf0ffbf1a7a82caf39d0e19607b0030fb668de (patch) | |
tree | 4c4a66541dfe10c6d6b1bcfbaa9a52ca5b54898e /OpenSim/Client/Sirikata/Protocol/MessageHeader.cs | |
parent | Merge branch 'master' of git://opensimulator.org/git/opensim (diff) | |
parent | Remove sirikata project (diff) | |
download | opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.zip opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.tar.gz opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.tar.bz2 opensim-SC_OLD-84cf0ffbf1a7a82caf39d0e19607b0030fb668de.tar.xz |
Merge branch 'master' of git://opensimulator.org/git/opensim
Diffstat (limited to 'OpenSim/Client/Sirikata/Protocol/MessageHeader.cs')
-rw-r--r-- | OpenSim/Client/Sirikata/Protocol/MessageHeader.cs | 630 |
1 files changed, 0 insertions, 630 deletions
diff --git a/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs b/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs deleted file mode 100644 index 22e10f7..0000000 --- a/OpenSim/Client/Sirikata/Protocol/MessageHeader.cs +++ /dev/null | |||
@@ -1,630 +0,0 @@ | |||
1 | // Generated by the protocol buffer compiler. DO NOT EDIT! | ||
2 | |||
3 | using pb = global::Google.ProtocolBuffers; | ||
4 | using pbc = global::Google.ProtocolBuffers.Collections; | ||
5 | using pbd = global::Google.ProtocolBuffers.Descriptors; | ||
6 | using scg = global::System.Collections.Generic; | ||
7 | namespace Sirikata.Protocol._PBJ_Internal { | ||
8 | |||
9 | public static partial class MessageHeader { | ||
10 | |||
11 | #region Extension registration | ||
12 | public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { | ||
13 | } | ||
14 | #endregion | ||
15 | #region Static variables | ||
16 | internal static pbd::MessageDescriptor internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor; | ||
17 | internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.Header, global::Sirikata.Protocol._PBJ_Internal.Header.Builder> internal__static_Sirikata_Protocol__PBJ_Internal_Header__FieldAccessorTable; | ||
18 | #endregion | ||
19 | #region Descriptor | ||
20 | public static pbd::FileDescriptor Descriptor { | ||
21 | get { return descriptor; } | ||
22 | } | ||
23 | private static pbd::FileDescriptor descriptor; | ||
24 | |||
25 | static MessageHeader() { | ||
26 | byte[] descriptorData = global::System.Convert.FromBase64String( | ||
27 | "ChNNZXNzYWdlSGVhZGVyLnByb3RvEh9TaXJpa2F0YS5Qcm90b2NvbC5fUEJK" + | ||
28 | "X0ludGVybmFsIooDCgZIZWFkZXISFQoNc291cmNlX29iamVjdBgBIAEoDBIT" + | ||
29 | "Cgtzb3VyY2VfcG9ydBgDIAEoDRIVCgxzb3VyY2Vfc3BhY2UYgAwgASgMEhoK" + | ||
30 | "EmRlc3RpbmF0aW9uX29iamVjdBgCIAEoDBIYChBkZXN0aW5hdGlvbl9wb3J0" + | ||
31 | "GAQgASgNEhoKEWRlc3RpbmF0aW9uX3NwYWNlGIEMIAEoDBIKCgJpZBgHIAEo" + | ||
32 | "AxIQCghyZXBseV9pZBgIIAEoAxJMCg1yZXR1cm5fc3RhdHVzGIAOIAEoDjI0" + | ||
33 | "LlNpcmlrYXRhLlByb3RvY29sLl9QQkpfSW50ZXJuYWwuSGVhZGVyLlJldHVy" + | ||
34 | "blN0YXR1cyJ/CgxSZXR1cm5TdGF0dXMSCwoHU1VDQ0VTUxAAEhMKD05FVFdP" + | ||
35 | "UktfRkFJTFVSRRABEhMKD1RJTUVPVVRfRkFJTFVSRRADEhIKDlBST1RPQ09M" + | ||
36 | "X0VSUk9SEAQSEAoMUE9SVF9GQUlMVVJFEAUSEgoOVU5LTk9XTl9PQkpFQ1QQ" + | ||
37 | "Bg=="); | ||
38 | pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | ||
39 | descriptor = root; | ||
40 | internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor = Descriptor.MessageTypes[0]; | ||
41 | internal__static_Sirikata_Protocol__PBJ_Internal_Header__FieldAccessorTable = | ||
42 | new pb::FieldAccess.FieldAccessorTable<global::Sirikata.Protocol._PBJ_Internal.Header, global::Sirikata.Protocol._PBJ_Internal.Header.Builder>(internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor, | ||
43 | new string[] { "SourceObject", "SourcePort", "SourceSpace", "DestinationObject", "DestinationPort", "DestinationSpace", "Id", "ReplyId", "ReturnStatus", }); | ||
44 | return null; | ||
45 | }; | ||
46 | pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | ||
47 | new pbd::FileDescriptor[] { | ||
48 | }, assigner); | ||
49 | } | ||
50 | #endregion | ||
51 | |||
52 | } | ||
53 | #region Messages | ||
54 | public sealed partial class Header : pb::GeneratedMessage<Header, Header.Builder> { | ||
55 | private static readonly Header defaultInstance = new Builder().BuildPartial(); | ||
56 | public static Header DefaultInstance { | ||
57 | get { return defaultInstance; } | ||
58 | } | ||
59 | |||
60 | public override Header DefaultInstanceForType { | ||
61 | get { return defaultInstance; } | ||
62 | } | ||
63 | |||
64 | protected override Header ThisMessage { | ||
65 | get { return this; } | ||
66 | } | ||
67 | |||
68 | public static pbd::MessageDescriptor Descriptor { | ||
69 | get { return global::Sirikata.Protocol._PBJ_Internal.MessageHeader.internal__static_Sirikata_Protocol__PBJ_Internal_Header__Descriptor; } | ||
70 | } | ||
71 | |||
72 | protected override pb::FieldAccess.FieldAccessorTable<Header, Header.Builder> InternalFieldAccessors { | ||
73 | get { return global::Sirikata.Protocol._PBJ_Internal.MessageHeader.internal__static_Sirikata_Protocol__PBJ_Internal_Header__FieldAccessorTable; } | ||
74 | } | ||
75 | |||
76 | #region Nested types | ||
77 | public static class Types { | ||
78 | public enum ReturnStatus { | ||
79 | SUCCESS = 0, | ||
80 | NETWORK_FAILURE = 1, | ||
81 | TIMEOUT_FAILURE = 3, | ||
82 | PROTOCOL_ERROR = 4, | ||
83 | PORT_FAILURE = 5, | ||
84 | UNKNOWN_OBJECT = 6, | ||
85 | } | ||
86 | |||
87 | } | ||
88 | #endregion | ||
89 | |||
90 | public const int SourceObjectFieldNumber = 1; | ||
91 | private bool hasSourceObject; | ||
92 | private pb::ByteString sourceObject_ = pb::ByteString.Empty; | ||
93 | public bool HasSourceObject { | ||
94 | get { return hasSourceObject; } | ||
95 | } | ||
96 | public pb::ByteString SourceObject { | ||
97 | get { return sourceObject_; } | ||
98 | } | ||
99 | |||
100 | public const int SourcePortFieldNumber = 3; | ||
101 | private bool hasSourcePort; | ||
102 | private uint sourcePort_ = 0; | ||
103 | public bool HasSourcePort { | ||
104 | get { return hasSourcePort; } | ||
105 | } | ||
106 | [global::System.CLSCompliant(false)] | ||
107 | public uint SourcePort { | ||
108 | get { return sourcePort_; } | ||
109 | } | ||
110 | |||
111 | public const int SourceSpaceFieldNumber = 1536; | ||
112 | private bool hasSourceSpace; | ||
113 | private pb::ByteString sourceSpace_ = pb::ByteString.Empty; | ||
114 | public bool HasSourceSpace { | ||
115 | get { return hasSourceSpace; } | ||
116 | } | ||
117 | public pb::ByteString SourceSpace { | ||
118 | get { return sourceSpace_; } | ||
119 | } | ||
120 | |||
121 | public const int DestinationObjectFieldNumber = 2; | ||
122 | private bool hasDestinationObject; | ||
123 | private pb::ByteString destinationObject_ = pb::ByteString.Empty; | ||
124 | public bool HasDestinationObject { | ||
125 | get { return hasDestinationObject; } | ||
126 | } | ||
127 | public pb::ByteString DestinationObject { | ||
128 | get { return destinationObject_; } | ||
129 | } | ||
130 | |||
131 | public const int DestinationPortFieldNumber = 4; | ||
132 | private bool hasDestinationPort; | ||
133 | private uint destinationPort_ = 0; | ||
134 | public bool HasDestinationPort { | ||
135 | get { return hasDestinationPort; } | ||
136 | } | ||
137 | [global::System.CLSCompliant(false)] | ||
138 | public uint DestinationPort { | ||
139 | get { return destinationPort_; } | ||
140 | } | ||
141 | |||
142 | public const int DestinationSpaceFieldNumber = 1537; | ||
143 | private bool hasDestinationSpace; | ||
144 | private pb::ByteString destinationSpace_ = pb::ByteString.Empty; | ||
145 | public bool HasDestinationSpace { | ||
146 | get { return hasDestinationSpace; } | ||
147 | } | ||
148 | public pb::ByteString DestinationSpace { | ||
149 | get { return destinationSpace_; } | ||
150 | } | ||
151 | |||
152 | public const int IdFieldNumber = 7; | ||
153 | private bool hasId; | ||
154 | private long id_ = 0L; | ||
155 | public bool HasId { | ||
156 | get { return hasId; } | ||
157 | } | ||
158 | public long Id { | ||
159 | get { return id_; } | ||
160 | } | ||
161 | |||
162 | public const int ReplyIdFieldNumber = 8; | ||
163 | private bool hasReplyId; | ||
164 | private long replyId_ = 0L; | ||
165 | public bool HasReplyId { | ||
166 | get { return hasReplyId; } | ||
167 | } | ||
168 | public long ReplyId { | ||
169 | get { return replyId_; } | ||
170 | } | ||
171 | |||
172 | public const int ReturnStatusFieldNumber = 1792; | ||
173 | private bool hasReturnStatus; | ||
174 | private global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus.SUCCESS; | ||
175 | public bool HasReturnStatus { | ||
176 | get { return hasReturnStatus; } | ||
177 | } | ||
178 | public global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus ReturnStatus { | ||
179 | get { return returnStatus_; } | ||
180 | } | ||
181 | |||
182 | public override bool IsInitialized { | ||
183 | get { | ||
184 | return true; | ||
185 | } | ||
186 | } | ||
187 | |||
188 | public override void WriteTo(pb::CodedOutputStream output) { | ||
189 | if (HasSourceObject) { | ||
190 | output.WriteBytes(1, SourceObject); | ||
191 | } | ||
192 | if (HasDestinationObject) { | ||
193 | output.WriteBytes(2, DestinationObject); | ||
194 | } | ||
195 | if (HasSourcePort) { | ||
196 | output.WriteUInt32(3, SourcePort); | ||
197 | } | ||
198 | if (HasDestinationPort) { | ||
199 | output.WriteUInt32(4, DestinationPort); | ||
200 | } | ||
201 | if (HasId) { | ||
202 | output.WriteInt64(7, Id); | ||
203 | } | ||
204 | if (HasReplyId) { | ||
205 | output.WriteInt64(8, ReplyId); | ||
206 | } | ||
207 | if (HasSourceSpace) { | ||
208 | output.WriteBytes(1536, SourceSpace); | ||
209 | } | ||
210 | if (HasDestinationSpace) { | ||
211 | output.WriteBytes(1537, DestinationSpace); | ||
212 | } | ||
213 | if (HasReturnStatus) { | ||
214 | output.WriteEnum(1792, (int) ReturnStatus); | ||
215 | } | ||
216 | UnknownFields.WriteTo(output); | ||
217 | } | ||
218 | |||
219 | private int memoizedSerializedSize = -1; | ||
220 | public override int SerializedSize { | ||
221 | get { | ||
222 | int size = memoizedSerializedSize; | ||
223 | if (size != -1) return size; | ||
224 | |||
225 | size = 0; | ||
226 | if (HasSourceObject) { | ||
227 | size += pb::CodedOutputStream.ComputeBytesSize(1, SourceObject); | ||
228 | } | ||
229 | if (HasSourcePort) { | ||
230 | size += pb::CodedOutputStream.ComputeUInt32Size(3, SourcePort); | ||
231 | } | ||
232 | if (HasSourceSpace) { | ||
233 | size += pb::CodedOutputStream.ComputeBytesSize(1536, SourceSpace); | ||
234 | } | ||
235 | if (HasDestinationObject) { | ||
236 | size += pb::CodedOutputStream.ComputeBytesSize(2, DestinationObject); | ||
237 | } | ||
238 | if (HasDestinationPort) { | ||
239 | size += pb::CodedOutputStream.ComputeUInt32Size(4, DestinationPort); | ||
240 | } | ||
241 | if (HasDestinationSpace) { | ||
242 | size += pb::CodedOutputStream.ComputeBytesSize(1537, DestinationSpace); | ||
243 | } | ||
244 | if (HasId) { | ||
245 | size += pb::CodedOutputStream.ComputeInt64Size(7, Id); | ||
246 | } | ||
247 | if (HasReplyId) { | ||
248 | size += pb::CodedOutputStream.ComputeInt64Size(8, ReplyId); | ||
249 | } | ||
250 | if (HasReturnStatus) { | ||
251 | size += pb::CodedOutputStream.ComputeEnumSize(1792, (int) ReturnStatus); | ||
252 | } | ||
253 | size += UnknownFields.SerializedSize; | ||
254 | memoizedSerializedSize = size; | ||
255 | return size; | ||
256 | } | ||
257 | } | ||
258 | |||
259 | public static Header ParseFrom(pb::ByteString data) { | ||
260 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
261 | } | ||
262 | public static Header ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | ||
263 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
264 | } | ||
265 | public static Header ParseFrom(byte[] data) { | ||
266 | return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | ||
267 | } | ||
268 | public static Header ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | ||
269 | return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | ||
270 | } | ||
271 | public static Header ParseFrom(global::System.IO.Stream input) { | ||
272 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
273 | } | ||
274 | public static Header ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
275 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
276 | } | ||
277 | public static Header ParseDelimitedFrom(global::System.IO.Stream input) { | ||
278 | return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | ||
279 | } | ||
280 | public static Header ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | ||
281 | return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | ||
282 | } | ||
283 | public static Header ParseFrom(pb::CodedInputStream input) { | ||
284 | return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | ||
285 | } | ||
286 | public static Header ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
287 | return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | ||
288 | } | ||
289 | public static Builder CreateBuilder() { return new Builder(); } | ||
290 | public override Builder ToBuilder() { return CreateBuilder(this); } | ||
291 | public override Builder CreateBuilderForType() { return new Builder(); } | ||
292 | public static Builder CreateBuilder(Header prototype) { | ||
293 | return (Builder) new Builder().MergeFrom(prototype); | ||
294 | } | ||
295 | |||
296 | public sealed partial class Builder : pb::GeneratedBuilder<Header, Builder> { | ||
297 | protected override Builder ThisBuilder { | ||
298 | get { return this; } | ||
299 | } | ||
300 | public Builder() {} | ||
301 | |||
302 | Header result = new Header(); | ||
303 | |||
304 | protected override Header MessageBeingBuilt { | ||
305 | get { return result; } | ||
306 | } | ||
307 | |||
308 | public override Builder Clear() { | ||
309 | result = new Header(); | ||
310 | return this; | ||
311 | } | ||
312 | |||
313 | public override Builder Clone() { | ||
314 | return new Builder().MergeFrom(result); | ||
315 | } | ||
316 | |||
317 | public override pbd::MessageDescriptor DescriptorForType { | ||
318 | get { return global::Sirikata.Protocol._PBJ_Internal.Header.Descriptor; } | ||
319 | } | ||
320 | |||
321 | public override Header DefaultInstanceForType { | ||
322 | get { return global::Sirikata.Protocol._PBJ_Internal.Header.DefaultInstance; } | ||
323 | } | ||
324 | |||
325 | public override Header BuildPartial() { | ||
326 | if (result == null) { | ||
327 | throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | ||
328 | } | ||
329 | Header returnMe = result; | ||
330 | result = null; | ||
331 | return returnMe; | ||
332 | } | ||
333 | |||
334 | public override Builder MergeFrom(pb::IMessage other) { | ||
335 | if (other is Header) { | ||
336 | return MergeFrom((Header) other); | ||
337 | } else { | ||
338 | base.MergeFrom(other); | ||
339 | return this; | ||
340 | } | ||
341 | } | ||
342 | |||
343 | public override Builder MergeFrom(Header other) { | ||
344 | if (other == global::Sirikata.Protocol._PBJ_Internal.Header.DefaultInstance) return this; | ||
345 | if (other.HasSourceObject) { | ||
346 | SourceObject = other.SourceObject; | ||
347 | } | ||
348 | if (other.HasSourcePort) { | ||
349 | SourcePort = other.SourcePort; | ||
350 | } | ||
351 | if (other.HasSourceSpace) { | ||
352 | SourceSpace = other.SourceSpace; | ||
353 | } | ||
354 | if (other.HasDestinationObject) { | ||
355 | DestinationObject = other.DestinationObject; | ||
356 | } | ||
357 | if (other.HasDestinationPort) { | ||
358 | DestinationPort = other.DestinationPort; | ||
359 | } | ||
360 | if (other.HasDestinationSpace) { | ||
361 | DestinationSpace = other.DestinationSpace; | ||
362 | } | ||
363 | if (other.HasId) { | ||
364 | Id = other.Id; | ||
365 | } | ||
366 | if (other.HasReplyId) { | ||
367 | ReplyId = other.ReplyId; | ||
368 | } | ||
369 | if (other.HasReturnStatus) { | ||
370 | ReturnStatus = other.ReturnStatus; | ||
371 | } | ||
372 | this.MergeUnknownFields(other.UnknownFields); | ||
373 | return this; | ||
374 | } | ||
375 | |||
376 | public override Builder MergeFrom(pb::CodedInputStream input) { | ||
377 | return MergeFrom(input, pb::ExtensionRegistry.Empty); | ||
378 | } | ||
379 | |||
380 | public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | ||
381 | pb::UnknownFieldSet.Builder unknownFields = null; | ||
382 | while (true) { | ||
383 | uint tag = input.ReadTag(); | ||
384 | switch (tag) { | ||
385 | case 0: { | ||
386 | if (unknownFields != null) { | ||
387 | this.UnknownFields = unknownFields.Build(); | ||
388 | } | ||
389 | return this; | ||
390 | } | ||
391 | default: { | ||
392 | if (pb::WireFormat.IsEndGroupTag(tag)) { | ||
393 | if (unknownFields != null) { | ||
394 | this.UnknownFields = unknownFields.Build(); | ||
395 | } | ||
396 | return this; | ||
397 | } | ||
398 | if (unknownFields == null) { | ||
399 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
400 | } | ||
401 | ParseUnknownField(input, unknownFields, extensionRegistry, tag); | ||
402 | break; | ||
403 | } | ||
404 | case 10: { | ||
405 | SourceObject = input.ReadBytes(); | ||
406 | break; | ||
407 | } | ||
408 | case 18: { | ||
409 | DestinationObject = input.ReadBytes(); | ||
410 | break; | ||
411 | } | ||
412 | case 24: { | ||
413 | SourcePort = input.ReadUInt32(); | ||
414 | break; | ||
415 | } | ||
416 | case 32: { | ||
417 | DestinationPort = input.ReadUInt32(); | ||
418 | break; | ||
419 | } | ||
420 | case 56: { | ||
421 | Id = input.ReadInt64(); | ||
422 | break; | ||
423 | } | ||
424 | case 64: { | ||
425 | ReplyId = input.ReadInt64(); | ||
426 | break; | ||
427 | } | ||
428 | case 12290: { | ||
429 | SourceSpace = input.ReadBytes(); | ||
430 | break; | ||
431 | } | ||
432 | case 12298: { | ||
433 | DestinationSpace = input.ReadBytes(); | ||
434 | break; | ||
435 | } | ||
436 | case 14336: { | ||
437 | int rawValue = input.ReadEnum(); | ||
438 | if (!global::System.Enum.IsDefined(typeof(global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus), rawValue)) { | ||
439 | if (unknownFields == null) { | ||
440 | unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | ||
441 | } | ||
442 | unknownFields.MergeVarintField(1792, (ulong) rawValue); | ||
443 | } else { | ||
444 | ReturnStatus = (global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus) rawValue; | ||
445 | } | ||
446 | break; | ||
447 | } | ||
448 | } | ||
449 | } | ||
450 | } | ||
451 | |||
452 | |||
453 | public bool HasSourceObject { | ||
454 | get { return result.HasSourceObject; } | ||
455 | } | ||
456 | public pb::ByteString SourceObject { | ||
457 | get { return result.SourceObject; } | ||
458 | set { SetSourceObject(value); } | ||
459 | } | ||
460 | public Builder SetSourceObject(pb::ByteString value) { | ||
461 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
462 | result.hasSourceObject = true; | ||
463 | result.sourceObject_ = value; | ||
464 | return this; | ||
465 | } | ||
466 | public Builder ClearSourceObject() { | ||
467 | result.hasSourceObject = false; | ||
468 | result.sourceObject_ = pb::ByteString.Empty; | ||
469 | return this; | ||
470 | } | ||
471 | |||
472 | public bool HasSourcePort { | ||
473 | get { return result.HasSourcePort; } | ||
474 | } | ||
475 | [global::System.CLSCompliant(false)] | ||
476 | public uint SourcePort { | ||
477 | get { return result.SourcePort; } | ||
478 | set { SetSourcePort(value); } | ||
479 | } | ||
480 | [global::System.CLSCompliant(false)] | ||
481 | public Builder SetSourcePort(uint value) { | ||
482 | result.hasSourcePort = true; | ||
483 | result.sourcePort_ = value; | ||
484 | return this; | ||
485 | } | ||
486 | public Builder ClearSourcePort() { | ||
487 | result.hasSourcePort = false; | ||
488 | result.sourcePort_ = 0; | ||
489 | return this; | ||
490 | } | ||
491 | |||
492 | public bool HasSourceSpace { | ||
493 | get { return result.HasSourceSpace; } | ||
494 | } | ||
495 | public pb::ByteString SourceSpace { | ||
496 | get { return result.SourceSpace; } | ||
497 | set { SetSourceSpace(value); } | ||
498 | } | ||
499 | public Builder SetSourceSpace(pb::ByteString value) { | ||
500 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
501 | result.hasSourceSpace = true; | ||
502 | result.sourceSpace_ = value; | ||
503 | return this; | ||
504 | } | ||
505 | public Builder ClearSourceSpace() { | ||
506 | result.hasSourceSpace = false; | ||
507 | result.sourceSpace_ = pb::ByteString.Empty; | ||
508 | return this; | ||
509 | } | ||
510 | |||
511 | public bool HasDestinationObject { | ||
512 | get { return result.HasDestinationObject; } | ||
513 | } | ||
514 | public pb::ByteString DestinationObject { | ||
515 | get { return result.DestinationObject; } | ||
516 | set { SetDestinationObject(value); } | ||
517 | } | ||
518 | public Builder SetDestinationObject(pb::ByteString value) { | ||
519 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
520 | result.hasDestinationObject = true; | ||
521 | result.destinationObject_ = value; | ||
522 | return this; | ||
523 | } | ||
524 | public Builder ClearDestinationObject() { | ||
525 | result.hasDestinationObject = false; | ||
526 | result.destinationObject_ = pb::ByteString.Empty; | ||
527 | return this; | ||
528 | } | ||
529 | |||
530 | public bool HasDestinationPort { | ||
531 | get { return result.HasDestinationPort; } | ||
532 | } | ||
533 | [global::System.CLSCompliant(false)] | ||
534 | public uint DestinationPort { | ||
535 | get { return result.DestinationPort; } | ||
536 | set { SetDestinationPort(value); } | ||
537 | } | ||
538 | [global::System.CLSCompliant(false)] | ||
539 | public Builder SetDestinationPort(uint value) { | ||
540 | result.hasDestinationPort = true; | ||
541 | result.destinationPort_ = value; | ||
542 | return this; | ||
543 | } | ||
544 | public Builder ClearDestinationPort() { | ||
545 | result.hasDestinationPort = false; | ||
546 | result.destinationPort_ = 0; | ||
547 | return this; | ||
548 | } | ||
549 | |||
550 | public bool HasDestinationSpace { | ||
551 | get { return result.HasDestinationSpace; } | ||
552 | } | ||
553 | public pb::ByteString DestinationSpace { | ||
554 | get { return result.DestinationSpace; } | ||
555 | set { SetDestinationSpace(value); } | ||
556 | } | ||
557 | public Builder SetDestinationSpace(pb::ByteString value) { | ||
558 | pb::ThrowHelper.ThrowIfNull(value, "value"); | ||
559 | result.hasDestinationSpace = true; | ||
560 | result.destinationSpace_ = value; | ||
561 | return this; | ||
562 | } | ||
563 | public Builder ClearDestinationSpace() { | ||
564 | result.hasDestinationSpace = false; | ||
565 | result.destinationSpace_ = pb::ByteString.Empty; | ||
566 | return this; | ||
567 | } | ||
568 | |||
569 | public bool HasId { | ||
570 | get { return result.HasId; } | ||
571 | } | ||
572 | public long Id { | ||
573 | get { return result.Id; } | ||
574 | set { SetId(value); } | ||
575 | } | ||
576 | public Builder SetId(long value) { | ||
577 | result.hasId = true; | ||
578 | result.id_ = value; | ||
579 | return this; | ||
580 | } | ||
581 | public Builder ClearId() { | ||
582 | result.hasId = false; | ||
583 | result.id_ = 0L; | ||
584 | return this; | ||
585 | } | ||
586 | |||
587 | public bool HasReplyId { | ||
588 | get { return result.HasReplyId; } | ||
589 | } | ||
590 | public long ReplyId { | ||
591 | get { return result.ReplyId; } | ||
592 | set { SetReplyId(value); } | ||
593 | } | ||
594 | public Builder SetReplyId(long value) { | ||
595 | result.hasReplyId = true; | ||
596 | result.replyId_ = value; | ||
597 | return this; | ||
598 | } | ||
599 | public Builder ClearReplyId() { | ||
600 | result.hasReplyId = false; | ||
601 | result.replyId_ = 0L; | ||
602 | return this; | ||
603 | } | ||
604 | |||
605 | public bool HasReturnStatus { | ||
606 | get { return result.HasReturnStatus; } | ||
607 | } | ||
608 | public global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus ReturnStatus { | ||
609 | get { return result.ReturnStatus; } | ||
610 | set { SetReturnStatus(value); } | ||
611 | } | ||
612 | public Builder SetReturnStatus(global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus value) { | ||
613 | result.hasReturnStatus = true; | ||
614 | result.returnStatus_ = value; | ||
615 | return this; | ||
616 | } | ||
617 | public Builder ClearReturnStatus() { | ||
618 | result.hasReturnStatus = false; | ||
619 | result.returnStatus_ = global::Sirikata.Protocol._PBJ_Internal.Header.Types.ReturnStatus.SUCCESS; | ||
620 | return this; | ||
621 | } | ||
622 | } | ||
623 | static Header() { | ||
624 | object.ReferenceEquals(global::Sirikata.Protocol._PBJ_Internal.MessageHeader.Descriptor, null); | ||
625 | } | ||
626 | } | ||
627 | |||
628 | #endregion | ||
629 | |||
630 | } | ||